Progblemet #4

;; Detta definierar ett Java-interface "under huven" med namnet                                    
;; "Animal" och en metod med namnet "make-sound"                                                   
(defprotocol Animal
  (make-sound [this]))

;; Låt typen "Dog" implementerar interfacet "Animal"                                               
(deftype Dog[name]
  Animal
  (make-sound [this] (println name ": voff")))

;; Låt typen "Cat" implementerar interfacet "Animal"                                               
(deftype Cat[name]
  Animal
  (make-sound [this] (println name ": mjao")))

;; Skapa lite hundar och katter och säg åt dem att låta!                                           
(doseq [animal [(Dog. "Killer") (Cat. "Tom") (Dog. "Lufsen") (Dog. "Lady")]]
  (make-sound animal))

;; Clojure är ett starkt och dynamiskt typat språk, man kan därför                                 
;; stoppa in saker av vilken typ som helst i listor. Vill man veta om                              
;; ett visst objekt implementerar ett visst protokoll så kan man göra                              
;; så här.                                                                                         
(doseq [maybe-animal ["not animal" (Cat. "Bill")]]
  (if (satisfies? Animal maybe-animal) (make-sound maybe-animal)))

(defmulti make-sound :type)
(defmethod make-sound ::dog [this] (println (:name this) ": voff"))
(defmethod make-sound ::cat [this] (println (:name this) ": mjao"))

;; Här är "klasserna" representerad rakt upp och ner med hjälp av hash-maps
;; Namnet är sparat under nyckeln ":name" och typen under nyckeln ":type"
(defn new-dog [name] {:type ::dog :name name})
(defn new-cat [name] {:type ::cat :name name})

(doseq [animal [(new-dog "Killer") (new-cat "Tom") (new-dog "Lufsen") (new-dog "Lady")]]
  (make-sound animal))

;; Går att ha en metod som tar hand om alla typer man inte känner                                  
;; igen.                                                                                           
(defmethod make-sound :default [this] (println "inte en katt eller hund"))
(doseq [maybe-animal ["not animal" (new-cat "Bill")]]
  (make-sound maybe-animal))

;; Det går också att skapa relatationer mellan atomer (det som börjar                              
;; med kolon i Lisp/Clojure är en "atom" som är en form av konstant                                
;; utan värde). Man kan sedan frågan om 'x' är relaterad till 'y' på                               
;; följande sätt.                                                                                  
(derive ::dog ::animal) ;; ::dog är ett barn till ::animal                                         
(derive ::cat ::animal) ;; ::cat är ett bart till ::animal                                         
(doseq [maybe-animal ["not animal" (new-cat "Bill")]]
  (if (isa? (:type maybe-animal) ::animal) (make-sound maybe-animal)))

package main

import "fmt"

// Så låt oss börja med att skapa ett interface för ett djur. Det                   
// specifierar vilka metoder en typ måste ha för att kunne användas som             
// ett djur.                                                                        
type Animal interface {
    // låt oss i stället retunera ljudet som en sträng                              
    makeSound() string
}

// Vår hund har även i detta fall bara ett namn                                     
type Dog struct {
    name string
}

// Samma sak gäller katten, bara ett namn                                           
type Cat struct {
    name string
}

// Detta lägger till metoden 'makeSound' till typen 'Dog' och typen                 
// uppfyller därmed interfacet Animal                                               
func (dog Dog) makeSound() string {
    return dog.name + " : voff"
}

// Samma sak för 'Cat'.                                                             
func (cat Cat) makeSound() string {
    return cat.name + " : mjao"
}

func main() {
    animals := []Animal{Dog{"Killer"},Cat{"Tom"},Dog{"Lufsen"},Dog{"Lady"}}
    for _, animal := range(animals) {
        fmt.Println(animal.makeSound())
    }

    // Detta skulle leda till kompileringsfel då typen "string" inte                
    // uppfyller interfacet 'Animal'                                                
    //                                                                              
    // maybe_animals = []Animal{Dog{"Lassie"},"Not an animal"}                      
    //                                                                              
    // Det är däremot full möjligt för oss att lägga göra så att                    
    // 'string' uppfyller detta genom att lägga till metoden                        
    //                                                                              
    // func (a_string string) makeSound() string {                                              
    //    return a_string + " can now be used as an animal!"                        
    // }                                                                            
    //                                                                              
    // Exemplet skulle nu kompilera                                                 
}