*rnd*

Random instance for use in generators. By consistently using this
instance you can get a repeatable basis for tests.

anything

Usage: (anything)

Returns a scalar or collection based on *rnd*.

boolean

Usage: (boolean)

Returns a bool based on *rnd*.

boolean-array

Usage: (boolean-array f)
       (boolean-array f sizer)

Create an array with elements from f and sized from sizer.

byte

Usage: (byte)

Returns a long based on *rnd* in the byte range.

byte-array

Usage: (byte-array f)
       (byte-array f sizer)

Create an array with elements from f and sized from sizer.

char

Usage: (char)

Returns a character based on *rnd* in the range 0-65536.

char-array

Usage: (char-array f)
       (char-array f sizer)

Create an array with elements from f and sized from sizer.

collection

Usage: (collection)

Returns a collection of scalar elements based on *rnd*.

date

Usage: (date)
       (date base)

Create a date with geometric mean around base which defaults to
#inst "2007-10-16T00:00:00.000-00:00"

default-sizer

Usage: (default-sizer)

Default sizer used to run tests. If you want a specific distribution,
create your own and pass it to a fn that wants a sizer.

double

Usage: (double)

Generate a double between 0 and 1 based on *rnd*.

double-array

Usage: (double-array f)
       (double-array f sizer)

Create an array with elements from f and sized from sizer.

float

Usage: (float)

Generate a float between 0 and 1 based on *rnd*

float-array

Usage: (float-array f)
       (float-array f sizer)

Create an array with elements from f and sized from sizer.

geometric

Usage: (geometric p)

Geometric distribution with mean 1/p.

hash-map

Usage: (hash-map fk fv)
       (hash-map fk fv sizer)

Create a hash-map with keys from fk, vals from fv, and
sized from sizer.

int

Usage: (int)

Returns a int based on *rnd* in the int range.

int-array

Usage: (int-array f)
       (int-array f sizer)

Create an array with elements from f and sized from sizer.

keyword

Usage: (keyword)
       (keyword sizer)

Create a non-namespaced keyword sized from sizer.

list

Usage: (list f)
       (list f sizer)

Create a list with elements from f and sized from sizer.

long

Returns a long based on *rnd*. Same as uniform.

long-array

Usage: (long-array f)
       (long-array f sizer)

Create an array with elements from f and sized from sizer.

one-of

Usage: (one-of & specs)

Generates one of the specs passed in, with equal probability.

printable-ascii-char

Usage: (printable-ascii-char)

Returns a char based on *rnd* in the printable ascii range.

rand-nth

Usage: (rand-nth coll)

Replacement of core/rand-nth that allows control of the
randomization basis (through binding *rnd*).

ratio

Usage: (ratio)
       (ratio num-gen denom-gen)

Generate a ratio, with numerator and denominator uniform longs
or as specified

reps

Usage: (reps sizer f)

Returns sizer repetitions of f (or (f) if f is a fn).

reservoir-sample

Usage: (reservoir-sample ct coll)

Reservoir sample ct items from coll, using *rnd*.

scalar

Usage: (scalar)

Returns a scalar based on *rnd*.

set

Usage: (set f)
       (set f sizer)

Create a set with elements from f and sized from sizer.

short

Usage: (short)

Returns a short based on *rnd* in the short range.

short-array

Usage: (short-array f)
       (short-array f sizer)

Create an array with elements from f and sized from sizer.

shuffle

Usage: (shuffle coll)

Shuffle coll based on *rnd*

string

Usage: (string)
       (string f)
       (string f sizer)

Create a string with chars from f and sized from sizer.

symbol

Usage: (symbol)
       (symbol sizer)

Create a non-namespaced symbol sized from sizer.

tuple

Usage: (tuple & generators)

Generate a tuple with one element from each generator.

uniform

Usage: (uniform)
       (uniform lo hi)

Uniform distribution from lo (inclusive) to hi (exclusive).
Defaults to range of Java long.

uuid

Usage: (uuid)

Create a UUID based on uniform distribution of low and high parts.

vec

Usage: (vec f)
       (vec f sizer)

Create a vec with elements from f and sized from sizer.

weighted

Usage: (weighted m)

Given a map of generators and weights, return a value from one of
the generators, selecting generator based on weights.