               {:name "label" :doc "a label string"}
               {:name "run", :default 1.0 :doc "activation switch 0 or 1"}],
        :rates #{:dr}
-       :doc "Print the value of an input demand ugen."}
+       :doc "Print the value of an input demand ugen. The print-out is in the form: label: value block offset: offset.
+
+WARNING: Printing values from the Server in intensive for the CPU. Poll should be used for debugging purposes.
+"}
       ])

      ;; which is implemented in the pseudo-ugen DUGen parent of below

      {:name "Dseries",
       :args [{:name "start", :default 1}
              {:name "step", :default 1}
              {:name "length", :default INFINITE}]
       :rates #{:dr}
       :doc "Generate a series of incrementing values on demand."}

      {:name "Dgeom",
       :args [{:name "start", :default 1}
              {:name "grow", :default 2}
              {:name "length", :default INFINITE}]
       :rates #{:dr}
       :doc "Generate a geometric sequence on demand."}

      {:name "Dbufrd",
       :args [{:name "bufnum", :default 0.0}
              {:name "phase", :default 0.0}
              {:name "loop", :default 1.0}],
       :rates #{:dr}
       :doc "Read values from a buffer on demand, using phase (index) value that is also pulled on demand."}

      {:name "Dbufwr",
       :args [{:name "input", :default 0.0}
              {:name "bufnum", :default 0}
              {:name "phase", :default 0.0}
              {:name "loop", :default 1.0}],
       :rates #{:dr}
       :doc "Write a demand sequence into a buffer."}

      {:name "Dseq",
       :args [{:name "list", :mode :append-sequence, :array true}
              {:name "repeats", :default 1}],
       :rates #{:dr}
       :doc "Output a sequence of values, possibly repeating multiple times."}

      {:name "Dser"
       :args [{:name "list", :mode :append-sequence, :array true}
              {:name "count", :default 1}],
       :doc "Generates a sequence of values Like dseq, except outputs only count total values, rather than repeating."}

      {:name "Dshuf" :extends "Dseq"
       :doc "Shuffle a sequence once and then output it one or more times."}

      {:name "Drand" :extends "Dseq"
       :doc "Generate a random ordering of an input sequence."}

      {:name "Dxrand" :extends "Dseq"
       :doc "Generate a random ordering of the given sequence without repeating any element until all elements have been returned."}

      {:name "Dswitch1",
       :args [{:name "list", :mode :append-sequence, :array true}
              {:name "index"}],
       :rates #{:dr}
       :doc "A demand rate switch that can be used to select one of multiple demand rate inputs."}

      {:name "Dswitch" :extends "Dswitch1"
       :doc "A demand rate switch."}

      {:name "Dwhite",
       :args [{:name "lo", :default 0.0}
              {:name "hi", :default 1.0}
              {:name "length", :default INFINITE}]
       :rates #{:dr}
       :doc "Generate a sequence of random values between lo and hi."}

      {:name "Diwhite" :extends "Dwhite"
       :doc "Generates a sequence of random integer values between lo and hi."}

      {:name "Dbrown",
       :args [{:name "lo", :default 0.0}
              {:name "hi", :default 1.0}
              {:name "step", :default 0.01}
              {:name "length", :default INFINITE}]
       :rates #{:dr}
       :doc "Generates a sequence of random values betweeen lo and hi, not exceeding step from one value to the next."}

      {:name "Dibrown" :extends "Dbrown"
       :doc "Generates a sequence of random integer values betweeen lo and hi, not exceeding step from one value to the next."}

      {:name "Dstutter",
       :args [{:name "n"}
              {:name "in"}],
       :rates #{:dr}
       :doc "Replicates input values n times on demand.  Both inputs can be demand rate ugens."}


                                  (ir? reset)
                                  (rate-of? reset rate))))
                  "TODO write error string. and understad why this is an error"))
       :doc "Expects demand ugen args for dur and level.  Uses successive dur values to determine how long to wait before emitting each level value.

A value is demanded each ugen in the list and output according to a stream of duration values.
The unit generators in the list should be 'demand' rate.

When there is a trigger at the reset input, the demand rate ugens in the list and the duration are reset. The reset input may also be a demand ugen, providing a stream of reset times."}

      {:name "TDuty" :extends "Duty"
       :args [{:name "dur", :default 1.0 :doc "time values. Can be a demand ugen or any signal. The next trigger value is acquired after the duration provided by the last time value."}
              {:name "reset", :default 0.0 :doc "trigger or reset time values. Resets the list of ugens and the duration ugen when triggered. The reset input may also be a demand ugen, providing a stream of reset times."}
              {:name "level", :default 1.0 :doc "demand ugen providing the output values."}
              {:name "action", :default 0 :map DONE-ACTIONS}
              {:name "gapFirst", :default 0}]
       :doc "A value is demanded each ugen in the list and output  as a trigger according to a stream of duration values. The unit generators in the list should be 'demand' rate.

When there is a trigger at the reset input, the demand rate ugens in the list and the duration are reset.The reset input may also be a demand ugen, providing a stream of reset times."}

      {:name "DemandEnvGen",
       :args [{:name "level" :doc "demand ugen (or other ugen) returning level values"}
              {:name "dur" :doc "demand ugen (or other ugen) returning time values"}
              {:name "shape", :default 1 :doc "demand ugen (or other ugen) returning shape number - the number given is the shape number"}
              {:name "curve", :default 0 :doc "demand ugen (or other ugen) returning curve values -  if shape is 5, this is the curve factor. Thee possible values are: 0 - flat segments, 1 - linear segments, the default, 2 - natural exponential growth and decay. In this case, the levels must all be nonzero and the have the same sign, 3 - sinusoidal S shaped segments, 4 - sinusoidal segments shaped like the sides of a Welch window, a Float - a curvature value for all segments, an Array of Floats - curvature values for each segments."
               }
              {:name "gate", :default 1.0 :doc "control rate gate if gate is x >= 1, the ugen runs, if gate is 0 > x > 1, the ugen is released at the next level (doneAction), if gate is x <= 0, the ugen is sampled end held"}
              {:name "reset", :default 1.0 :doc "if reset crosses from nonpositive to positive, the ugen is reset at the next level. If it is > 1, it is reset immediately."}
              {:name "levelScale", :default 1.0 :doc "demand ugen returning level scaling values"}
              {:name "levelBias", :default 0.0 :doc "demand ugen returning level offset values"}
              {:name "timeScale", :default 1.0 :doc "demand ugen returning time scaling values"}
              {:name "action", :default :none :map DONE-ACTIONS}]
       :init (fn [rate [l d s c gate reset ls lb ts da] spec]
               (if (or (ar? gate) (ar? reset))
                 [l d s c (as-ar gate) (as-ar reset) ls lb ts da]))
       :doc "Plays back break point envelope contours (levels, times, shapes) given by demand ugens. The next values are called when the next node is reached."}

      ;; DUGen : UGen {
      ;;  init { arg ... argInputs;
