@spec any() :: type()

All Elixir terms (that PropEr can produce).

For reasons of efficiency, functions are never produced as instances of this type.

CAUTION: Instances of this type are expensive to produce, shrink and instance- check, both in terms of processing time and consumed memory. Only use this type if you are certain that you need it.

@spec arity() :: type()

Arity is a byte value, i.e. integer(0, 255)

@spec atom() :: type()

All atoms.

All atoms used internally by PropEr start with a :$ , so such atoms will never be produced as instances of this type. You should also refrain from using such atoms in your code, to avoid a potential clash. Instances shrink towards the empty atom, :"".

@spec binary() :: type()

All binaries.

Instances shrink towards the empty binary, "".

@spec binary(non_neg_integer()) :: type()

All binaries with a byte size of length.

length must be an Elixir expression that evaluates to a non-negative integer. Instances shrink towards binaries of zeroes.

@spec bitstring() :: type()

All bitstrings.

Instances shrink towards the empty bitstring, "".

@spec bitstring(non_neg_integer()) :: type()

All bitstrings with a bit size of length.

length must be an Elixir expression that evaluates to a non-negative integer. Instances shrink towards bitstrings of zeroes.

@spec bool() :: type()

bool is equivalent to boolean

@spec boolean() :: type()

The atoms true and false. Instances shrink towards false.

@spec byte() :: type()

Byte values, i.e. integer(0, 255)

@spec char() :: type()

Char values (16 bit for some reason), i.e. integer(0, 0xffff)

@spec char_list() :: type()

An Erlang string, i.e. list(char)

@spec choose(ext_int(), ext_int()) :: type()

choose is equivalent to integer(low, high)

@spec default(raw_type(), raw_type()) :: type()

Adds a default value, default_value, to type.

The default serves as a primary shrinking target for instances, while it is also chosen by the random instance generation subsystem half the time.

@spec elements([raw_type(), ...]) :: type()

elements is equivalent to union([..])

@spec exactly(any()) :: type()

Singleton type consisting only of value.

value must be an evaluated term. Also written simply as value.

@spec fixed_list([raw_type()]) :: type()

All lists whose i-th element is an instance of the type at index i of list_of_types. Also written simply as a list of types.

@spec float() :: type()

All floats, i.e. float(:inf, :inf)

@spec float(ext_float(), ext_float()) :: type()

All floats between low and high, bounds included.

low and high must be Elixir expressions that evaluate to floats, with Low =< high. Additionally, low and high may have the value :inf, in which case they represent minus infinity and plus infinity respectively. Instances shrink towards 0.0 if low =< 0.0 =< high, or towards the bound with the smallest absolute value otherwise.

@spec frequency([{frequency(), raw_type()}, ...]) :: type()

frequency is equivalent to weighted_union([..])

@spec function0(type()) :: type()

A function with 0 parameters, i.e. function(0, ret_type)

@spec function1(type()) :: type()

A function with 1 parameter, i.e. function(1, ret_type)

@spec function2(type()) :: type()

A function with 2 parameters, i.e. function(2, ret_type)

@spec function3(type()) :: type()

A function with 3 parameters, i.e. function(3, ret_type)

@spec function4(type()) :: type()

A function with 4 parameters, i.e. function(4, ret_type)

@spec function([raw_type()] | arity(), raw_type()) :: type()

All pure functions that map instances of arg_types to instances of ret_type.

The syntax function(arity, ret_type) is also acceptable.

@spec int() :: type()

Small integers (bound by the current value of the size parameter).

Instances shrink towards 0.

@spec integer() :: type()

All integers, i.e. integer(:inf, :inf)

@spec integer(ext_int(), ext_int()) :: type()

All integers between low and high, bounds included.

low and high must be Elixir expressions that evaluate to integers, with low =< high. Additionally, low and high may have the value :inf, in which case they represent minus infinity and plus infinity respectively. Instances shrink towards 0 if low =< 0 =< high, or towards the bound with the smallest absolute value otherwise.

@spec large_int() :: type()

Large_int is equivalent to integer

@spec list() :: type()

List of any types, i.e. list(any)

@spec list(raw_type()) :: type()

All lists containing elements of type elem_type.

Instances shrink towards the empty list, [].

@spec loose_tuple(raw_type()) :: type()

Tuples whose elements are all of type elem_type.

Instances shrink towards the 0-size tuple, {}.

@spec map(raw_type(), raw_type()) :: type()

A map whose keys are defined by the generator k and values by the generator v.

@spec nat() :: type()

Small Small non-negative integers (bound by the current value of the size parameter).

Instances shrink towards 0.

@spec neg_integer() :: type()

Negative integers, i.e. integer(:inf, -1)

@spec non_empty(raw_type()) :: type()

This is a predefined constraint that can be applied to random-length list and binary types to ensure that the produced values are never empty.

Use for e.g. list/0, char_list/0, binary/0

@spec non_neg_float() :: type()

Non negative floats, i.e. float(0.0, inf)

@spec non_neg_integer() :: type()

Non negative integers, i.e. integer(0, :inf)

@spec noshrink(raw_type()) :: type()

Creates a new type which is equivalent to type, but whose instances are never shrunk by the shrinking subsystem.

@spec number() :: type()

Numbers are integers or floats, i.e. union([integer(), float()])

@spec oneof([raw_type(), ...]) :: type()

oneof is equivalent to union([..])

@spec ordered_list(raw_type()) :: type()

All sorted lists containing elements of type elem_type.

Instances shrink towards the empty list, [].

@spec parameter(atom()) :: value()

Returns the value associated with parameter, or :undefined in case parameter is not associated with any value.

Association occurs with calling with_parameter/3 or with_parameters/2 before.

@spec parameter(atom(), value()) :: value()

Returns the value associated with parameter, or default in case parameter is not associated with any value.

Association occurs with calling with_parameter/3 or with_parameters/2 before.

@spec pos_integer() :: type()

Strictly positive integers, i.e. integer(1, :inf)

@spec range(ext_int(), ext_int()) :: type()

A range is equivalent to integers

@spec real() :: type()

real is equivalent to float

@spec resize(size(), raw_type()) :: type()

Overrides the size parameter used when generating instances of type with new_size.

Has no effect on size-less types, such as unions. Also, this will not affect the generation of any internal types contained in type, such as the elements of a list - those will still be generated using the test-wide value of size. One use of this function is to modify types to produce instances that grow faster or slower, like so:

iex> quickcheck(forall l <- list(integer()) do
...>   length(l) <= 42
...> end)
true

iex> long_list = sized(size, resize(size * 2, list(integer())))
iex> really_long = such_that_maybe l <- long_list, when:
...>      length(l) > 42
iex> quickcheck(forall l <- really_long do
...>   (length(l) <= 84)
...>   |> measure("List length", length l)
...>   |> collect(length l)
...> end)
true

The above specifies a list type that grows twice as fast as normal lists.

@spec return(any()) :: type()

return is equivalent to exactly

@spec shrink_list([any()]) :: type()

A type that generates exactly the list list.

Instances shrink towards shorter sublists of the original list.

@spec term() :: type()

Term is a synonym for any

@spec timeout() :: type()

timeout values, i.e. union([non_neg_integer() | :infinity])

@spec tuple() :: type()

Tuples of any types, i.e. loose_tuple(any)

@spec tuple([raw_type()]) :: type()

All tuples whose i-th element is an instance of the type at index i of list_of_types.

Also written simply as a tuple of types.

@spec union([raw_type(), ...]) :: type()

The union of all types in list_of_types.

list_of_types can't be empty. The random instance generator is equally likely to choose any one of the types in list_of_types. The shrinking subsystem will always try to shrink an instance of a type union to an instance of the first type in list_of_types, thus you should write the simplest case first.

@spec utf8() :: type()

utf8-encoded unbounded size binary

@spec utf8(ext_non_neg_integer()) :: type()

utf8-encoded bounded upper size binary.

@spec utf8(ext_non_neg_integer(), 1..4) :: type()

Bounded upper size utf8 binary, codepoint length =< MaxCodePointSize.

Limiting codepoint size can be useful when applications do not accept full unicode range. For example, MySQL in utf8 encoding accepts only 3-byte unicode codepoints in VARCHAR fields.

If unbounded length is needed, use :inf as first argument.

@spec vector(non_neg_integer(), raw_type()) :: type()

All lists of length length containing elements of type elem_type.

length must be an Elixir expression that evaluates to a non-negative integer.

@spec weighted_default({frequency(), raw_type()}, {frequency(), raw_type()}) :: type()

A specialization of default/2.

Parameters default and type are assigned weights to be considered by the random instance generator. The shrinking subsystem will ignore the weights and try to shrink using the default value.

@spec weighted_union([{frequency(), raw_type()}, ...]) :: type()

A specialization of union/1, where each type in list_of_types is assigned a frequency.

Frequencies must be Elixir expressions that evaluate to positive integers. Types with larger frequencies are more likely to be chosen by the random instance generator. The shrinking subsystem will ignore the frequencies and try to shrink towards the first type in the list.

@spec with_parameter(atom(), value(), raw_type()) :: type()

Associates the atom key parameter with the value value while generating instances of type.

@spec with_parameters([{atom(), value()}], raw_type()) :: type()

Similar to with_parameter/3, but accepts a list of {parameter, value} pairs.

@spec wunion([{frequency(), raw_type()}, ...]) :: type()

weighted_union(FreqChoices)