 
 ; default expression change preserving
 
-(defmethod changes->form :default 
+(defmethod changes->form* :default 
   ([expr {struct-changes :structure
           id->prop-changes :properties} _]
-   (apply list '-> expr
-     (concat struct-changes
-             (for [[morph prop-changes] id->prop-changes]
-               (apply concat (for [[prop value] prop-changes]
-                               (list 'set-prop morph prop value))))))))
+   (if (or (not-empty struct-changes) (-> id->prop-changes empty? not))
+     (apply list '-> expr
+       (apply concat struct-changes
+         (for [[morph prop-changes] id->prop-changes]
+           (concat (for [[prop value] prop-changes]
+                     (list '=> morph prop value))))))
+     expr)))
 
 (defmulti apply-changes 
   "Applies the changes to the expression and also updates the change meta-data accordingly"
   (fn [expr changes] (ast-type expr)))
 
 (defmethod apply-changes :morph [morph changes]
-  (morph-eval (changes->form (-> morph meta :description) changes)))
+  (morph-eval (changes->form (-> morph meta :description) changes {})))
 
 (defmethod apply-changes :expr [expr changes]
   (let [new-description (changes->form (-> expr meta :description) changes {:expanded-expression expr})
         new-expansion (morph-eval new-description)]
     (vary-meta new-expansion merge
       {:expanded-expression? true
+       :init-description (expr meta :init-description)
        :description new-description})))
 
 ; SUBMORPH LENS

                                (changes->form 
                                  (-> expr meta :description) 
                                  (fetch expr changes) 
                                  {:expanded-expression new-expansion}))
                     ))))

; this will never happen, since (fetch [ vector ] [submorphs idx] == [idx])
(defmethod putback-submorphs :vector [morphs new-submorphs]


(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]
