(ns mtg.frame)

 

 ;; GENERALLY USEFUL FUNCTIONS

 

 (defn assay "Takes x and a series of pred-value pairs. Returns a list of vals for which the corresponding preds are true of x." [x & pred-vals]

   (reduce #(if ((first %2) x) (conj %1 (second %2))) '() pred-vals)

   )

 (defn alter-val "Applies f to the current value associated with each key, associating each key with the value returned." [m f & keys]

   (map #(assoc m % (f (get m %))) keys))

 

 (defn every-nth "Returns every nth member of coll. If n is not positive, returns an empty list." [n coll]

   (if (<= n 0) '()

   (take-while (comp not nil?) (map first (iterate #(nthnext % n) coll)))))

 

 

 

 

 

 ;; FRAME MANIPULATION

 

 (defn conj-key "Adds the xs to the seq associated with the given key." [map key & xs]

  (assoc map key (apply conj (get map key []) xs)))

 

 (defn update "Takes a frame and a sequence of key-fn pairs. Applies f to the current value associated with key, updating the current value with the result.  Frames generate and store a unique id for each call to update."

   [frame & kfs]

   (let [id (gensym "")

 	keys (every-nth 2 kfs)

 	fns (every-nth 2 (rest kfs))]

 

     ((reduce comp (map (fn[k f](fn[m](conj-key m k (list id f)))) keys fns))

     (conj-key frame :*bindings* (map (fn [k f](list id k)) keys fns))

     )

 ))

 

 (defn rollback "Undo the update with the given id." [frame id]

   (let [affected-keys

 	(conj (map second (filter #(=(first %) id) (:*bindings* frame))) :*bindings*)]

     (reduce (fn[frame key]

 	      (alter-val (partial filter #(=(first %) id)) key)

 	      ) frame affected-keys)

   ))

 

 

 (defn get-fn "Keys in a frame store lists of modifiers. Produces the end result of applying all the modifiers in order." [frame key]

     (reduce #(%2) (constantly nil) (list (constantly 1)))

 )

 

 

 (def *frame* (atom {:*bindings* '()}))