              (apply concat struct-changes
                (for [[morph prop-changes] id->prop-changes]
                  (apply concat (for [[prop value] prop-changes]
-                                 (list 'set-prop morph prop value))))))
+                                 (list '=> morph prop value))))))
        map-expr))))
 
-(defmethod changes->form 'for
+(defmethod changes->form* 'for
   ([for-expr {struct-changes :structurep
               id->prop-changes :properties} {loc :idx
                                              bound-props :bound-props}]

      (merge props unbound-changes)
      submorphs)))

(defmethod changes->form 'map
  ([map-expr {struct-changes :structure
              id->prop-changes :properties} {expr-morphs :expanded-expression}] 
   (let [[_ map-fn & rest-expr] map-expr


(declare add-morph add-morph-before without set-prop)

(defn bi-lens? [x]
  (and (satisfies? IFetch x) (satisfies? IPutback x)))

; unpack the previously added changes (BUG: what if expression originally comes with a '-> ?)

(defmulti changes->form* (fn [expr changes opts] 
                          (if (:loop-mapping opts) 
                            (first expr)
                            :default)))

(defn changes->form 
  ([expr changes opts]
   (let [expr (if (= '-> (first expr)) (second expr) expr)]
     (changes->form* expr changes opts))))

(defn modify-prototype [prototype-expr unbound-changes]
  (let [[self props & submorphs] prototype-expr]
