               :outputs (repeat n-outputs {:rate (rate RATES)})
               :n-inputs 0
               :inputs []}
-            {:type :ugen}))
+    {:type :ugen}))
 
 (defn control? [obj]
   (isa? (type obj) ::control))

    [[]]
    (let [gc-seqs (fn [[gcount seqs flags] arg]
                    (cond
                      ; Infinite seqs can be used to generate values for expansion
                      (inf? arg) [gcount
                                  (conj seqs arg)
                                  (next flags)]

                      ; Regular, non-infinite and non-map collections get expanded
                      (and (expandable? arg)
                           (first flags)) [(max gcount (count arg))
                                           (conj seqs (cycle arg))
                                           (next flags)]

                      :else ; Basic values get used for all expansions
                      [gcount
                       (conj seqs (repeat arg))
                       (next flags)]))
          [greatest-count seqs] (reduce gc-seqs [1 [] expand-flags] args)]
      (take greatest-count (parallel-seqs seqs)))))


(defn- inf? [obj]
  (:infinite-sequence (meta obj)))

;; Does it really make sense to cycle over the values of a collection when
;; doing expansion?  I don't think maps should be allowed as arguments, unless
;; this is a strategy at having named arguments, but then the ordering wouldn't
;; make sense.
;;(defn- cycle-vals [coll]
;;  (cycle (if (map? coll) (vals coll) coll)))

(defn- expandable? [arg]
  (and (coll? arg)
