                         repeat?
                         (loop [res (apply func (concat args [data]))]
                           (cond
-                            (done? res) :nop
-                            (more? res) (recur (apply func args))
+                            (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
-                            (do (doseq [ch outputs] (>! ch res))
-                                (recur (apply func args)))))
+                            (when res
+                              (doseq [ch outputs] (>! ch res)))))
                         :else
                         (let [res (apply func (concat args [data]))]
                           (cond
-                            (more? res) :nop
+                            (need? res) :nop ; outer loop gets next data set
                             (done? res) (vswap! short-circuit? truefn)
                             :else
                             (when res
-                              (doseq [ch outputs]
-                                (>! ch res))))))
+                              (doseq [ch outputs] (>! ch res))))))
                       (catch Exception e
                         (warnf "%s, Exception %s\n %s\n %s"
                                (funcm :id) e args data))))


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

(defn more?

  (func-node :n->1))

(defn one2n? [func-node]
  (func-node :1->n))

(defn need
  "Inside function nodes, call this to indicate more values are needed
  to generate next output."
  []
  ::nextinput)

(defn need? [res]
  (= res ::nextinput))


