Logo Hegel for F#

Gen Module

The generator catalogue for F#. The scalar generators are the C# ones, whose builder methods (Gen.int.Min(0).Max(10)) narrow them; the collection, option, tuple, record and union generators are F#'s own, drawing F# values and printing them as F#. Generators compose with , and , or in a gen { } block.

Nested modules

Modules Description

Temporal

The date and time generators, under the names every Hegel frontend shares. The values they draw, and ZoneSource, are in the Hegel.FSharp.Temporal namespace.

Functions and values

Function or value Description

Gen.array element

Full Usage: Gen.array element

Parameters:
Returns: ArrayGen<'T>
Type parameters: 'T

Arrays of values of ; .MinSize, .MaxSize and .Unique narrow them.

element : Generator<'T>
Returns: ArrayGen<'T>

Gen.auto

Full Usage: Gen.auto

Returns: Generator<'T>
Type parameters: 'T

A generator derived from the type: F# records, unions (recursive ones through their base cases), options, lists, arrays, sets, maps and tuples, recursively, and every type Generators.ForType knows. Derived once per type.

Returns: Generator<'T>

Gen.bigint

Full Usage: Gen.bigint

Returns: BigIntegerGenerator

Arbitrary-precision integers; .Min and .Max bound them.

Returns: BigIntegerGenerator

Gen.bind f generator

Full Usage: Gen.bind f generator

Parameters:
Returns: Generator<'U>
Type parameters: 'T, 'U

A value of , then one of the generator gives for it.

f : 'T -> Generator<'U>
generator : Generator<'T>
Returns: Generator<'U>

Gen.bool

Full Usage: Gen.bool

Returns: Generator<bool>

Booleans, true and false equally often.

Returns: Generator<bool>

Gen.bytes

Full Usage: Gen.bytes

Returns: BinaryGenerator

Byte arrays; .MinSize and .MaxSize bound their length.

Returns: BinaryGenerator

Gen.char

Full Usage: Gen.char

Returns: Generator<char>

Characters other than surrogates.

Returns: Generator<char>

Gen.composite body

Full Usage: Gen.composite body

Parameters:
Returns: Generator<'T>
Type parameters: 'T

A generator written as a function of the test case, drawing what it needs; its value is printed.

body : TestCase -> 'T
Returns: Generator<'T>

Gen.constant value

Full Usage: Gen.constant value

Parameters:
    value : 'T

Returns: Generator<'T>
Type parameters: 'T

A generator of just .

value : 'T
Returns: Generator<'T>

Gen.deferred ()

Full Usage: Gen.deferred ()

Parameters:
    () : unit

Returns: Deferred<'T>
Type parameters: 'T

A generator set later with .Set, for one that refers to itself.

() : unit
Returns: Deferred<'T>

Gen.domain

Full Usage: Gen.domain

Returns: DomainGenerator

Domain names; .MaxLength bounds them.

Returns: DomainGenerator

Gen.email

Full Usage: Gen.email

Returns: Generator<string>

Email addresses.

Returns: Generator<string>

Gen.filter predicate generator

Full Usage: Gen.filter predicate generator

Parameters:
    predicate : 'T -> bool
    generator : Generator<'T>

Returns: Generator<'T>
Type parameters: 'T

The values of that accepts.

predicate : 'T -> bool
generator : Generator<'T>
Returns: Generator<'T>

Gen.float

Full Usage: Gen.float

Returns: DoubleGenerator

Floating-point numbers (64-bit); .Min, .Max, .AllowNan and .AllowInfinity narrow them.

Returns: DoubleGenerator

Gen.float32

Full Usage: Gen.float32

Returns: FloatGenerator

Floating-point numbers (32-bit); .Min, .Max, .AllowNan and .AllowInfinity narrow them.

Returns: FloatGenerator

Gen.guid

Full Usage: Gen.guid

Returns: UuidGenerator

GUIDs; .Version picks a UUID version.

Returns: UuidGenerator

Gen.int

Full Usage: Gen.int

Returns: IntegerGenerator

Integers (32-bit); .Min and .Max bound them.

Returns: IntegerGenerator

Gen.int64

Full Usage: Gen.int64

Returns: LongGenerator

Integers (64-bit); .Min and .Max bound them.

Returns: LongGenerator

Gen.ipAddress

Full Usage: Gen.ipAddress

Returns: IpAddressGenerator

IP addresses; .V4 and .V6 pick a version.

Returns: IpAddressGenerator

Gen.item values

Full Usage: Gen.item values

Parameters:
    values : 'T seq

Returns: Generator<'T>
Type parameters: 'T

A generator choosing uniformly among .

values : 'T seq
Returns: Generator<'T>

Gen.lark grammar

Full Usage: Gen.lark grammar

Parameters:
    grammar : string

Returns: LarkGenerator

Strings of the Lark ; .Start, .MaxSize and .MaxDepth narrow them.

grammar : string
Returns: LarkGenerator

Gen.list element

Full Usage: Gen.list element

Parameters:
Returns: ListGen<'T>
Type parameters: 'T

Lists of values of ; .MinSize, .MaxSize and .Unique narrow them.

element : Generator<'T>
Returns: ListGen<'T>

Gen.map f generator

Full Usage: Gen.map f generator

Parameters:
Returns: Generator<'U>
Type parameters: 'T, 'U

The values of transformed by .

f : 'T -> 'U
generator : Generator<'T>
Returns: Generator<'U>

Gen.map2 f a b

Full Usage: Gen.map2 f a b

Parameters:
Returns: Generator<'T>
Type parameters: 'A, 'B, 'T

f applied to a value from each generator.

f : 'A -> 'B -> 'T
a : Generator<'A>
b : Generator<'B>
Returns: Generator<'T>

Gen.map3 f a b c

Full Usage: Gen.map3 f a b c

Parameters:
Returns: Generator<'T>
Type parameters: 'A, 'B, 'C, 'T

f applied to a value from each generator.

f : 'A -> 'B -> 'C -> 'T
a : Generator<'A>
b : Generator<'B>
c : Generator<'C>
Returns: Generator<'T>

Gen.mapOf keys values

Full Usage: Gen.mapOf keys values

Parameters:
Returns: MapGen<'Key, 'Value>
Type parameters: 'Key, 'Value (requires comparison)

Maps with keys from and values from .

keys : Generator<'Key>
values : Generator<'Value>
Returns: MapGen<'Key, 'Value>

Gen.oneOf generators

Full Usage: Gen.oneOf generators

Parameters:
Returns: Generator<'T>
Type parameters: 'T

A generator drawing from one of , chosen uniformly.

generators : Generator<'T> seq
Returns: Generator<'T>

Gen.option generator

Full Usage: Gen.option generator

Parameters:
Returns: OptionGen<'T>
Type parameters: 'T

Options: None or Some of a value of .

generator : Generator<'T>
Returns: OptionGen<'T>

Gen.permutations items

Full Usage: Gen.permutations items

Parameters:
    items : 'T seq

Returns: Generator<'T list>
Type parameters: 'T

Permutations of .

items : 'T seq
Returns: Generator<'T list>

Gen.record

Full Usage: Gen.record

Returns: RecordGen<'T>
Type parameters: 'T

A generator for the record , each field derived from its type unless .With("Field", generator) says otherwise.

Returns: RecordGen<'T>

Gen.recursive baseCase extend

Full Usage: Gen.recursive baseCase extend

Parameters:
Returns: RecursiveGenerator<'T>
Type parameters: 'T

Recursive values: , extended by a bounded number of times; .MaxDepth and .MaxLeaves set the bounds.

baseCase : Generator<'T>
extend : Generator<'T> -> Generator<'T>
Returns: RecursiveGenerator<'T>

Gen.regex pattern

Full Usage: Gen.regex pattern

Parameters:
    pattern : string

Returns: RegexGenerator

Strings matching ; .FullMatch and .Alphabet narrow them.

pattern : string
Returns: RegexGenerator

Gen.samples items

Full Usage: Gen.samples items

Parameters:
    items : 'T seq

Returns: Generator<'T list>
Type parameters: 'T

Samples of : subsets of any size, in a drawn order.

items : 'T seq
Returns: Generator<'T list>

Gen.set element

Full Usage: Gen.set element

Parameters:
Returns: SetGen<'T>
Type parameters: 'T (requires comparison)

Sets of values of ; .MinSize and .MaxSize narrow them.

element : Generator<'T>
Returns: SetGen<'T>

Gen.string

Full Usage: Gen.string

Returns: TextGenerator

Strings; .MinSize, .MaxSize, .Alphabet and .Categories narrow them.

Returns: TextGenerator

Gen.subsequences items

Full Usage: Gen.subsequences items

Parameters:
    items : 'T seq

Returns: Generator<'T list>
Type parameters: 'T

Subsequences of , in their order.

items : 'T seq
Returns: Generator<'T list>

Gen.tuple2 a b

Full Usage: Gen.tuple2 a b

Parameters:
Returns: Generator<'A * 'B>
Type parameters: 'A, 'B

Pairs, one element from each generator.

a : Generator<'A>
b : Generator<'B>
Returns: Generator<'A * 'B>

Gen.tuple3 a b c

Full Usage: Gen.tuple3 a b c

Parameters:
Returns: Generator<'A * 'B * 'C>
Type parameters: 'A, 'B, 'C

Triples, one element from each generator.

a : Generator<'A>
b : Generator<'B>
c : Generator<'C>
Returns: Generator<'A * 'B * 'C>

Gen.tuple4 a b c d

Full Usage: Gen.tuple4 a b c d

Parameters:
Returns: Generator<'A * 'B * 'C * 'D>
Type parameters: 'A, 'B, 'C, 'D

Quadruples, one element from each generator.

a : Generator<'A>
b : Generator<'B>
c : Generator<'C>
d : Generator<'D>
Returns: Generator<'A * 'B * 'C * 'D>

Gen.tuple5 a b c d e

Full Usage: Gen.tuple5 a b c d e

Parameters:
Returns: Generator<'A * 'B * 'C * 'D * 'E>
Type parameters: 'A, 'B, 'C, 'D, 'E

Quintuples, one element from each generator.

a : Generator<'A>
b : Generator<'B>
c : Generator<'C>
d : Generator<'D>
e : Generator<'E>
Returns: Generator<'A * 'B * 'C * 'D * 'E>

Gen.url

Full Usage: Gen.url

Returns: Generator<string>

URLs.

Returns: Generator<string>

Gen.voption generator

Full Usage: Gen.voption generator

Parameters:
Returns: ValueOptionGen<'T>
Type parameters: 'T

Value options: ValueNone or ValueSome of a value of .

generator : Generator<'T>
Returns: ValueOptionGen<'T>

Gen.weightedBool p

Full Usage: Gen.weightedBool p

Parameters:
    p : float

Returns: Generator<bool>

Booleans, true with probability .

p : float
Returns: Generator<bool>

Gen.zip a b

Full Usage: Gen.zip a b

Parameters:
Returns: Generator<'A * 'B>
Type parameters: 'A, 'B

Pairs, one element from each generator: .

a : Generator<'A>
b : Generator<'B>
Returns: Generator<'A * 'B>

Type something to start searching.