#lang racket

(require math)

; Here's a basic interface for geometric shapes.
(define geometry/c
  (contract?
   (object-contract
    [area (-> number?)]
    [perim (-> number?)])))

; For our example we'll implement this interface on
; rect and circle types.
(struct rect (width height))
(struct circle (radius))

; To implement an interface in Racket, we define methods
; that satisfy the contract. Here we implement geometry/c on rects.
(define (rect-area r)
  (* (rect-width r) (rect-height r)))

(define (rect-perim r)
  (+ (* 2 (rect-width r)) (* 2 (rect-height r))))

; The implementation for circles.
(define (circle-area c)
  (* pi (sqr (circle-radius c))))

(define (circle-perim c)
  (* 2 pi (circle-radius c)))

; If a variable satisfies a contract, then we can call
; methods that are in the named interface. Here's a
; generic measure function taking advantage of this
; to work on any geometry.
(define (measure g)
  (printf "~a\n" g)
  (printf "~a\n" ((object-ref g 'area)))
  (printf "~a\n" ((object-ref g 'perim))))

(define (main)
  (define r (rect 3 4))
  (define c (circle 5))

  ; The circle and rect struct types both
  ; implement the geometry/c contract so we can use
  ; instances of these structs as arguments to measure.
  (measure (object
            [area (lambda () (rect-area r))]
            [perim (lambda () (rect-perim r))]))
  (measure (object
            [area (lambda () (circle-area c))]
            [perim (lambda () (circle-perim c))])))

(main)