     These can also be abbreviated:
     (foo :tgt 2 :pos :head)
     "
-    (let [arg-names (map keyword (map :name params))
-          args (if (and (= 1 (count args))
-                        (map? (first args))
-                        (not (id-able-type? (first args))))
-                 (flatten (seq (first args)))
-
-                 args)
+    (let [arg-names     (map keyword (map :name params))
+          args (or args [])
           [args sgroup] (if (or (= :target (first args))
                                 (= :tgt    (first args)))
                           [(drop 2 args) (second args)]

                               constants#)
                  constants# (into [] (set (concat constants# *constants*)))]
;;              (println "all ugens[" (count ugens#) "]: " ugens#)
       [~sname ~params ugens# constants#])))))

(defn synth-player
  [name params this & args]

                                (= :tgt    (first args)))
                          [(drop 2 args) (second args)]
                          [args sgroup])
          args          (mapcat (fn [x] (if (and (map? x)
                                                (not (id-able-type? x)))
                                         (flatten (seq x))
                                         [x]))
                                args)
          args          (map #(if (id-able-type? %)
                                (:id %) %) args)
          defaults      (into {} (map (fn [{:keys [name value]}]
                                        [(keyword name) @value])
                                      params))
          arg-map       (arg-mapper args arg-names defaults)
          synth-node    (node name arg-map {:position pos :target sgroup })
          synth-node    (if (:instance-fn this)
                          ((:instance-fn this) synth-node)
                          synth-node)]
      (when (:instance-fn this)
        (swap! active-synth-nodes* assoc (:id synth-node) synth-node))
      synth-node))
