       res
       (recur (>>2 res (first lmore)) (rest lmore)))))
 
+(defn- default-yank [data dflt]
+  (if (nil? data) dflt data))
+(defn- default-shove [v dflt]
+  (if (= dflt v) nil v))
+
 (defn default
-  "Returns a lens that shows nil as the given value, but does not change any other value."
-  [v]
-  (xmap #(if (nil? %) v %)
-        #(if (= v %) nil %)))
+  "Returns a lens that shows nil as the given default value, but does not change any other value."
+  [dflt]
+  (xmap default-yank default-shove dflt))
 
 (defn- consx [v coll]
   (if (and (nil? v) (empty? coll))

           %1
           (seq %2))))

(defn contains
  "Returns a lens showing the membership of the given value in a set."
  [v]
  (lens #(contains? % v)
        #(if %2
           (conj %1 v)
           (disj %1 v))))

(def ^{:doc "A lens that views a sequence of pairs as a map."}
  as-map
  (xmap #(into {} %) seq))

(defn member
  "Returns a lens showing the value mapped to the given key in a map,
  not-found or nil if key is not present. Note that when not-found (or
  nil) is shoved into the map, the association is removed."
  [key & [not-found]]
  (lens #(get % key not-found)
        #(if (= %2 not-found)
           (dissoc %1 key)
           (assoc %1 key %2))))

(def ^{:doc "A trivial lens that just shows nil over anything, and does never change anything."}
  void
  (lens (constantly nil) (fn [data _] data)))

(defn is
  "Returns a lens showing if a data structure equals the non-nil value v."
  [v]
  (assert (not (nil? v)))
  (lens #(= % v)
        #(if %2
           v
           (if (= %1 v)
             nil
             %1))))

(defn **
  "Return the product of several lenses, which means that each lens is
  held over an element of a collection in the order they appear in the
  argument list."
  [& lenses]
  (lens (fn [data] (map #(yank %1 %2)
                       data lenses))
        (fn [data v] (map #(shove %1 %2 %3)
                         data lenses v))))

;; not very general: 
;; (defn repeated

          reacl.lens/>>."}
  id (xmap identity identity))

(defn- comb-yank [data l1 l2]
  (yank (yank data l1) l2))
(defn- comb-shove [data v l1 l2]
  (shove data l1 (shove (yank data l1) l2 v)))

(defn- >>2
  [l1 l2]
  (lens comb-yank comb-shove l1 l2))

(defn >>
  "Returns a concatenation of two or more lenses, so that the combination shows the
