Std 0.2.5 API documentation

Wrap value in a vector if it is not sequential already
Ex:
  (coll-wrap 2)       ; => [2]
  (coll-wrap [1 2 3]) ; => [1 2 3]

Return the first value of x in coll that is logically true for (pred x)
Similar to clojure.core/some, but returns the item itself.

Ex: (find even? [1 1 1 3 4 5 6]) ; => 4

Takes two arguments in the reverse order of f ('flips' a function
of two arguments)
If supplied a function with no args, returns a new function
accepting the reversed args

Ex:
  (flip dissoc :foo {:foo 1 :bar 2})
  ; => {:bar 2}

  (def flipped-dissoc (flip dissoc))
  (flipped-dissoc :foo {:foo 1 :bar 2})
  ; => {:bar 2}

Attempt to parse x as EDN, or return nil on failure

Execute body repeatedly within a future, returning the future

Given symbols, e.g. `(map-from-keys foo bar)`,
return a map with those names as keyword keys, and those values:

Ex:
  (map-from-keys foo bar)
  ; => {:foo foo
        :bar bar}

Same as `map-tup` but returns results in a map

For all k,v in coll, return a seq of [(key-fn k) (val-fn v)] tuples

Ex:
  (map-tup #(* 2 %) #(* 3 %) {1 2, 3 4, 5 6})
  ; => ([2 6] [6 12] [10 18])

Like clojure.core/mapcat over a single coll without object
reachability memory issues. This is especially useful when
large seqs are generated by f, but this is a general-purpose
replacement for its clojure.core counterpart.

See http://clojurian.blogspot.com/2012/11/beware-of-mapcat.html
    http://stackoverflow.com/questions/21943577/mapcat-breaking-the-lazyness

Generate a string of random letters/digits of a given length

Generate a random int in the inclusive range of min-val to max-val

Same as clojure.core/shuffle but accepts source of randomness
for deterministic testing

pr-str x only if it is truthy, else return nil

When v is truthy, assoc it into coll at k. Otherwise return coll

When v is truthy, assoc it into coll at ks. Otherwise return coll

Zip corresponding elements from two or more colls together
Ex:
  (zip [1 2] [3 4])
  ; => [[1 3] [2 4]]

Given a collection `coll`, return a map where for all k in coll,
key of entry is (f k) and value of entry is (g k)

Ex:
  (zipmap-seq #(* 2 %) (* 3 %) [1 2 3])
  ;=> {2 3, 4 6, 6 9}