; Your code here!
(def simple-metric 
    {:meter 1, 
     :km 1000
     :cm 1/100
     :mm [1/10 :cm]})
 
#_(-> (* 3 (:km simple-metric))
    (+ (* 10 (:meter simple-metric)))
    (+ (* 80 (:cm simple-metric)))
    (+ (* (:cm simple-metric)(* 10 (first (:mm simple-metric)))))
    float)


; Listing 7.1 Function to recursively convert units of measure
#_(defn convert [context descriptor]
 (reduce (fn [result [mag unit]]
            (+ result 
               (let [val (get context unit)]
                (if (vector? val)
                 (* mag (convert context val))
                 (* mag val)))))
          0 (partition 2 descriptor)
          ))
      
      
      
;; Example of TRAMPOLINE 

(defn foo[x]
 (if (<  0)
 (println "done")
 #(foo (do (println :x x)(dec x)))))

(println (trampoline foo 5))





;; end of trampoline play       
    ; Listing 7.2 Using mutually recursive functions to implement a finite state machine  
(defn elevator 
    [commands]
    (letfn 
      [(ff-open [[_ & r]]
        "When the elevator is open on the 1st floor
        it can either close or be done."
        #(case _
        :close (ff-closed r)
        :done true
        false))
    (ff-closed [[_ & r]]
        "When the elevator is closed on the 1st floor
        it can either open or go up."
        #(case _
        :open (ff-open r)
        :up (sf-closed r)
        false))
    (sf-closed [[_ & r]]
        "When the elevator is closed on the 2nd floor
        it can either go down or open."
        #(case _
        :down (ff-closed r)
        :open (sf-open r)
        false))
    (sf-open [[_ & r]]
        "When the elevator is open on the 2nd floor
        it can either close or be done"
        #(case _
        :close (sf-closed r)
        :done true
        false))
                    ]
    (trampoline ff-open commands)))
; (println 
; (elevator [:close :open :close :up :open :open :done])
; (elevator [:close :up :open :close :down :open :done])
; ; (elevator (cycle [:close :open]))

; )