   (func-node :n->1))
 
 (defn one2n? [func-node]
-  (func-node :n->1))
-
-(defn nxt []
+  (func-node :1->n))
+
+(defn need
+  "Inside function nodes, call this to indicate more values are needed
+  to generate next output."
+  []
   ::nextinput)
 
-(defn nxt? [res]
+(defn need? [res]
   (= res ::nextinput))
 
 


(defn more
  "Inside 'generator/repeat' function nodes, call this to indicate
  there are move values to return."
  [] ::more)

(defn more?

                        repeat?
                        (loop [res (apply func (concat args [data]))]
                          (cond
                            (done? res) :nop ; repeat same as non
                            (need? res) :nop ; next data comes from channels
                            (more? res) :requires-mult-sigs-how-does-this-work?
                            :else
                            (when res
                              (doseq [ch outputs] (>! ch res)))))
                        :else
                        (let [res (apply func (concat args [data]))]
                          (cond
                            (need? res) :nop ; outer loop gets next data set
                            (done? res) (vswap! short-circuit? truefn)
                            :else
                            (when res
                              (doseq [ch outputs] (>! ch res))))))
                      (catch Exception e
                        (warnf "%s, Exception %s\n %s\n %s"
                               (funcm :id) e args data))))
