   [rand-seed size]
   (clojure.string/join (repeatedly size #(call-gen char rand-seed size))))
 
-(def string [:gen string-gen])
+(def string
+  "Generate strings"
+  [:gen string-gen])
 
 (defn string-ascii-gen
   [rand-seed size]
   (clojure.string/join (repeatedly size #(call-gen char-ascii rand-seed size))))
 
-(def string-ascii [:gen string-ascii-gen])
+(def string-ascii
+  "Generate ascii strings"
+  [:gen string-ascii-gen])
 
 (defn string-alpha-numeric-gen
   [rand-seed size]
   (clojure.string/join (repeatedly size #(call-gen char-alpha-numeric rand-seed size))))
 
-(def string-alpha-numeric [:gen string-alpha-numeric-gen])
+(def string-alpha-numeric
+  "Generate alpha-numeric strings"
+  [:gen string-alpha-numeric-gen])
 
 (defn shrink-string
   [s]

;; (generator and shrink strategy pretty much ripped from Haskell impl.)
;; ---------------------------------------------------------------------------

(def char (fmap clojure.core/char (choose 0 255)))

(def char-ascii (fmap clojure.core/char (choose 32 126)))

(def char-alpha-numeric (fmap clojure.core/char
                              (one-of [(choose 48 57)
                                       (choose 65 90)
                                       (choose 97 122)])))

(defn- stamp
  [c]

      (recur tail (- n chance)))))

(defn frequency
  "Create a generator that chooses a generator from `pairs` based on the
  provided likelihoods. The likelihood of a given generator being chosen is
  its likelihood divided by the sum of all likelihoods

  Examples:

    (gen/frequency [[5 gen/int] [3 (gen/vector gen/int)] [2 gen/boolean]])
  "
  [pairs]
  (let [total (apply + (clojure.core/map first pairs))]
    (bind (choose 1 total)
          (partial pick pairs))))

(defn elements
  "Create a generator that randomly chooses an element from `coll`.

  Examples:

    (gen/elements [:foo :bar :baz])"
  [coll]
  (fmap #(nth coll %)
        (choose 0 (dec (count coll)))))

(defn such-that
  "Create a generator that generates values from `gen` that satisfy predicate
  `f`. Care is needed to ensure there is a high chance `gen` will satisfy `f`,
  otherwise it will keep trying forever. Eventually we will add another
  generator combinator that only tries N times before giving up. In the Haskell
  version this is called `suchThatMaybe`.

  Examples:

    ;; generate non-empty vectors of integers
    (such-that (gen/vector gen/int) not-empty)"
  [gen f]
  [:gen (fn [rand-seed size]
    (let [value (call-gen gen rand-seed size)]
