               {: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.
+"}
       ])

                                  (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."}

      {:name "TDuty" :extends "Duty"
       :args [{:name "dur", :default 1.0}
              {:name "reset", :default 0.0}
              {:name "level", :default 1.0}
              {:name "action", :default 0 :map DONE-ACTIONS}
              {:name "gapFirst", :default 0}]}

      {:name "DemandEnvGen",
       :args [{:name "level"}
              {:name "dur"}
              {:name "shape", :default 1}
              {:name "curve", :default 0}
              {:name "gate", :default 1.0}
              {:name "reset", :default 1.0}
              {:name "levelScale", :default 1.0}
              {:name "levelBias", :default 0.0}
              {:name "timeScale", :default 1.0}
              {: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]))}

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

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

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

      {:name "Dgeom",
       :args [{:name "start", :default 1, :doc "start value"}
              {:name "grow", :default 2, :doc "value by which to grow ( x = x[-1] * grow )"}
              {:name "length", :default INFINITE, :doc "doc number of values to create"}]
       :rates #{:dr}
       :doc "Generate a geometric sequence on demand. The arguments can be a number or any other ugen"}

      {:name "Dbufrd",
       :args [{:name "bufnum", :default 0.0, :doc "buffer number to read from"}
              {:name "phase", :default 0.0, :doc "index into the buffer"}
              {:name "loop", :default 1.0, :doc "when phase exceeds number of frames in buffer, loops when set to 1"}],
       :rates #{:dr}
       :doc "Read values from a buffer on demand, using phase (index) value that is also pulled on demand. All inputs can be either demand ugen or any other ugen."}

      {:name "Dbufwr",
       :args [{:name "input", :default 0.0 :doc "single channel input"}
              {:name "bufnum", :default 0, :doc "buffer number to read from (single channel buffer)"}
              {:name "phase", :default 0.0, :doc "index into the buffer"}
              {:name "loop", :default 1.0, :doc "when phase exceeds number of frames in buffer, loops when set to 1"}],
       :rates #{:dr}
       :doc "Write a demand sequence into a buffer. All inputs can be either demand ugen or any other ugen."}

      {:name "Dseq",
       :args [{:name "list", :mode :append-sequence, :array true, :doc "array of values or other ugens"}
              {:name "num-repeats", :default 1, :doc "number of repeats"}],
       :rates #{:dr}
       :doc "Demand rate sequence generator. Outputs a sequence of values, possibly repeating multiple times. Use INFINITY as a repeat val to create an endless loop."}

      {:name "Dser"
       :args [{:name "list", :mode :append-sequence, :array true :doc "array of values or other ugens"}
              {:name "count", :default 1 :doc "number of values to return"}],
       :doc "Demand rate sequence generator. Generates a sequence of values Like dseq, except outputs only count total values, rather than repeating."}

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

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

      {:name "Dxrand" :extends "Dseq"
       :doc "Demand rate random sequence generator. 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 :doc "array of values or other ugens"}
              {:name "index" :doc "which of the inputs to return"}],
       :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. In difference to Dswitch1, Dswitch embeds all items of an input demand ugen first before looking up the next index."}

      {:name "Dwhite",
       :args [{:name "lo", :default 0.0 :doc "minimum value"}
              {:name "hi", :default 1.0 :doc "maximum value"}
              {:name "length", :default INFINITE :doc "number of values to create"}]
       :rates #{:dr}
       :doc "Generate a sequence of random values in the continuous range between lo and hi."}

      {:name "Diwhite" :extends "Dwhite"
       :doc "Generates a sequence of random integer values between lo and hi. The arguments can be a number or any other ugen"}

      {:name "Dbrown",
       :args [{:name "lo", :default 0.0 :doc "minimum value"}
              {:name "hi", :default 1.0 :doc "maximum value"}
              {:name "step", :default 0.01 :doc "maximum step for each new value"}
              {:name "length", :default INFINITE :doc "number of values to create"}]
       :rates #{:dr}
       :doc "Generates a sequence of random values in the continuous range betweeen lo and hi, not exceeding step from one value to the next. The arguments can be a number or any other ugen"}

      {: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. The arguments can be a number or any other ugen"}

      {:name "Dstutter",
       :args [{:name "num-repeats" :doc "number of repeats (can be a demand ugen)"}
              {:name "in" :doc "input ugen"}],
       :rates #{:dr}
       :doc "Replicates input values n times on demand.  Both inputs can be demand rate ugens."}

