       (async/onto-chan graph [(a 1) (b 2) (c 3) (a 10)])
       (is (= [1 3 6 15]
              (<! (async/into [] out)))))
-    (let [zero-arity-+-lift (z/map +)
-          zero-arity-vector-lift (z/map vector)]
-      (is (= 0 (:init zero-arity-+-lift)))
-      (is (= [] (:init zero-arity-vector-lift))))))
+    (let [zero-arity-+-map (z/map +)
+          zero-arity-vector-map (z/map vector)]
+      (is (= 0 (:init zero-arity-+-map)))
+      (is (= [] (:init zero-arity-vector-map))))))
 
 (deftest-async test-foldp
   (go

(deftest test-signal-sources
  (let [input (z/input 0)
        foldp (z/foldp + 0 input)
        lift (z/map vector input foldp)
        async (z/async lift)]
    (are [sig sources] (= (z/signal-deps sig) sources)
         input #{}
         foldp #{input}
         lift #{input foldp}
         async #{lift})))

(deftest test-output-node->dependency-map
  (let [input (z/input 0)
        foldp (z/foldp + 0 input)
        lift (z/map vector input foldp)
        async (z/async lift)]
    (are [out deps] (= (z/output-node->dependency-map out) deps)
         input {input #{}}
         foldp {input #{}
                foldp #{input}}
         lift {input #{}
               foldp #{input}
               lift #{input foldp}}
         async {input #{}
                foldp #{input}
                lift #{input foldp}
                async #{lift}})))

(deftest test-topsort
  (let [input (z/input 0)
        foldp (z/foldp + 0 input)
        lift (z/map vector input foldp)
        async (z/async lift)]
    (are [out sorted-sigs] (= (z/topsort out) sorted-sigs)
         input [input]
         foldp [input foldp]
         lift [input foldp lift]
         async [input foldp lift async])))

(deftest-async test-wiring-things-up
  (go

      (is (= [1 2 3]
             (<! (async/into [] out)))))))

(deftest-async test-map
  (go
    (let [number (event-constructor :numbers)
          in (z/input 0 :numbers)
