Generates a stream of values of any of the types: atom, float, int, list, map, string, and tuple. Structs are not included, as they require additional information to create.

If you need finer control over the types and values returned, see the choose/2 function.

Return a stream of random booleans (true or false).

Example

iex> import Pollution.{Generator, VG}
  iex> bool |> as_stream |> Enum.take(5)
  [true, false, true, true, false]

Each time a value is needed, randomly choose a generator from the list and invoke it.

Example

iex> import Pollution.{Generator, VG}
  iex> choose(from: [ int(min: 3, max: 7), bool ]) |> as_stream |> Enum.take(5)
  [6, false, 4, true, true]

Causes the stream never to output certain values. There are a few ways to use this:

Filters provided by the generator

iex> import Pollution.{Generator, VG} iex> string() |> as_stream() |> Enum.take(1) [“”] iex> string() |> except(:blank) |> as_stream() |> Enum.take(1) [“…”]

A provided function matcher

iex> import Pollution.{Generator, VG} iex> int() |> except(&(abs(&1) <= 1)) |> as_stream() |> Enum.take(3) [758, -995, -374]

A provided exact match

This exact match filter will not work with atoms due to the fact that atom names are used for named filters, so you must provide a function like &(&1 == :atom).

iex> import Pollution.{Generator, VG} iex> int() |> as_stream() |> Enum.take(3) [0, -1, 1] iex> int() |> except(-1) |> as_stream() |> Enum.take(3) [0, 1, 470]

A named predicate

This has no effect on the behavior, but it sets an internal name for the filter. This is useful if you intend to deal directly with the Pollution.State object, and would like to be able to see what filters have been applied.

iex> import Pollution.{Generator, VG} iex> int() |> except(:more_than_one_away_from_zero, &(abs(&1) <= 1)) |> as_stream() |> Enum.take(3) [758, -995, -374]

Return a stream of lists. Each list will have a random length (within limits), and each element in each list will be randomly chosen from the specified types.

Example

iex> import Pollution.{Generator, VG}
iex> list(of: bool, max: 7) |> as_stream|> Enum.take(5)
[
 [],
 [false, false, false],
 [false, true, true, false, true],
 [false, true, true, true, true, false, true],
 [true, true, false, false, false]
]

There are a few special-case constructors:

• list(length)

  Return lists of the given length

• list(generator)

  Return lists whose elements are created by generator

  iex> list(bool) |> as_stream|> Enum.take(5)

Otherwise, pass options:

• min: length

  Minimum length of the lists returned. Default 0

• max: length

  Maximum length of the lists returned. Default 100

• must_have: [ value, … ]

  Values that must be returned. Defaults to returning an empty list (so the parameter is must_have: [ [] ] if the minimum length is zero, nothing otherwise.

• of: generator

  Specifies the generator used to populate the lists.

Examples

iex> import Pollution.{Generator, VG}

  iex> list(of: int, min: 1, max: 5) |> as_stream |> Enum.take(4)
  [[0, -1, 1, -546], [442], [150], [-836, 540, -979]]

  iex> list(of: int, min: 1, max: 5) |> as_stream |> Enum.take(4)
  [[0], [-1, 1, 984, -206], [-246], [433, 125, -757]]

  iex> list(of: choose(from: [value(1), value(2)]), min: 1, max: 5)
  ...>         |> as_stream |> Enum.take(4)
  [[2], [1, 1, 2], [2, 2, 1, 1, 1], [2, 2, 1]]

  iex> list(of: seq(of: [value(1), value(2)]), min: 1, max: 5)
  ...>         |> as_stream |> Enum.take(4)
  [[1, 2], [1, 2, 1, 2], [1], [2, 1]]

Return a stream of floats not greater than -1.0. (Arguably this should be “not greater than -epsilon”). Same as float(max: -1.0)

Return a stream of integers less than 0. Same as int(max: -1)

Return a stream of floats greater than or equal to zero. Same as float(min: 0.0)

Return a stream of integers greater than or equal to 0. Same as int(min: 0)

Randomly chooses a generator from the list, and then returns a stream of values that it produces. This choice is made only once—call pick_one again to get a different result.

Examples

iex> import Pollution.{Generator, VG}
iex> stream = pick_one(from: [int, bool]) |> as_stream
iex> Enum.take(stream, 5)
[0, -1, 1, -223, 72]
iex> Enum.take(stream, 5)
[0, -1, 1, -553, 847]
iex> Enum.take(stream, 5)
[0, -1, 1, -518, -692]
iex> Enum.take(stream, 5)
[0, -1, 1, 580, 668]
iex> Enum.take(stream, 5)
[0, -1, 1, -989, -353]
iex> stream = pick_one(from: [int, bool]) |> as_stream
iex> Enum.take(stream, 5)
[true, false, false, false, false]
iex> Enum.take(stream, 5)
[false, true, false, false, false]

Return a stream of floats not less than 1.0. (Arguably this should be “not less than epsilon”). Same as float(min: 1.0)

Return a stream of integers not less than 1. Same as int(min: 1)

Give seq a list of generators (using the of: option). It will cycle through these as it streams values.

Examples

iex> import Pollution.{Generator, VG}
iex> seq(of: [int, bool, float]) |> as_stream |> Enum.take(10)
[0, true, 0.0, -1, true, -1.0, 1, true, 1.0, -702]

Generate a stream of structs. Before starting, the generator reflects on the struct that is passed in, looking at the types of the values of each field. It then maps this onto a map() generator, using appropriate subgenerators for each of those fields.

For example, given:

iex> defmodule MyStruct
 iex>    defstruct an_atom: :a, an_int: 0, other: nil
 iex> end

You could call

iex> struct(MyStruct)

As well as passing in the name of a struct, you can pass in an instance:

iex> struct(%MyStruct{})

In either case, the result would be a stream of MyStructs, as if you had called

map(like: %{ an_atom: atom,
             an_int:  int,
             other:   any,
             __struct__: MyStruct)

If you supply generators to the struct you pass in, these will be used in place of generators for the defaults:

struct(%MyStruct{an_int: int(min: 20), other: string})

Generates an infinite stream where each element is its parameter.

Example

iex> import Pollution.{Generator, VG}
iex> value("nom") |> as_stream |> Enum.take(3)
["nom", "nom", "nom"]