 (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)))
+;; 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)

                  :arglists (list (vec (map #(symbol (:name %))
                                            (:args spec))))}
        ugen-fns (map (fn [[uname rate]] [(with-meta (symbol uname) metadata)
                                          (make-ugen-fn spec rate special)])
                      (:fn-names spec))]
    (doseq [[ugen-name ugen-fn] ugen-fns]
      (intern to-ns ugen-name ugen-fn))))

        generics #{"+" "-" "*" "/"}]
    (doseq [op generics]
      (let [func (var-get (resolve (symbol "clojure.contrib.generic.arithmetic" op)))]
        (ns-unmap to-ns (symbol op))
        (intern to-ns (symbol op) (make-expanding func [true true]))))

    ;; intern div-meth so we can access the division operator since / is special cased
    (intern to-ns 'div-meth
            (make-expanding (var-get (resolve
                                      (symbol "clojure.contrib.generic.arithmetic" "/")))
                            [true true]))

    (doseq [[op-name special] UNARY-OPS-COLLIDE]
