(defpackage :geometry
  (:use :cl))

(in-package :geometry)

;; Here's a basic interface for geometric shapes.
(defgeneric area (shape)
  (:documentation "Calculate the area of a shape"))

(defgeneric perim (shape)
  (:documentation "Calculate the perimeter of a shape"))

;; For our example we'll implement this interface on
;; rect and circle types.
(defclass rect ()
  ((width :initarg :width :reader width)
   (height :initarg :height :reader height)))

(defclass circle ()
  ((radius :initarg :radius :reader radius)))

;; To implement an interface in Lisp, we just need to
;; define methods for the generic functions. Here we
;; implement area and perim on rects.
(defmethod area ((r rect))
  (* (width r) (height r)))

(defmethod perim ((r rect))
  (+ (* 2 (width r)) (* 2 (height r))))

;; The implementation for circles.
(defmethod area ((c circle))
  (* pi (expt (radius c) 2)))

(defmethod perim ((c circle))
  (* 2 pi (radius c)))

;; If a variable has a generic type, then we can call
;; methods that are defined for that generic function. Here's a
;; generic measure function taking advantage of this
;; to work on any shape.
(defun measure (shape)
  (format t "~A~%" shape)
  (format t "~A~%" (area shape))
  (format t "~A~%" (perim shape)))

(defun main ()
  (let ((r (make-instance 'rect :width 3 :height 4))
        (c (make-instance 'circle :radius 5)))
    ;; The circle and rect classes both
    ;; implement the area and perim generic functions so we can use
    ;; instances of these classes as arguments to measure.
    (measure r)
    (measure c)))

(main)