Gen

public struct Gen<T> : Identifiable

A type class capable of generating a value of type T from a given Context

  • id

    A stable identity for this generator

    Declaration

    Swift

    public let id: UUID
  • Initialize a new generator

    Declaration

    Swift

    public init(generator: @escaping (Context) throws -> T)

    Parameters

    generator

    The generator capable of generating a new value using the provided Context

Generation

  • Returns: A single value produced by the generator using the provided Context

    Declaration

    Swift

    func generate(context: Context = .default) -> T

    Parameters

    context

    The context to be used for generation

    Return Value

    A value of type T

  • Namespacing for safe static extension Gen

    Declaration

    Swift

    static var safe: SafeGen<T>.Type { get }
  • Namespacing for safe extension functions for Gen

    Declaration

    Swift

    var safe: SafeGen<T> { get }

Build

  • The composer class which passes in the context and allows us to generate more complex data with ease

    See more

    Declaration

    Swift

    struct GenComposer
  • Allows easy composition of various generators to create a complex model

    Declaration

    Swift

    static func compose(build: @escaping (GenComposer) -> T) -> Gen<T>

    Parameters

    build

    A callback which will produce the model of type T

    Return Value

    A generator which produces values of type T

  • Returns: A generator which constantly produces the provided value

    Declaration

    Swift

    static func constant(_ value: T) -> Gen<T>

    Parameters

    value

    The value which this generator will constantly create

    Return Value

    The generator

  • Returns: A generator which randomly produces values form the provided list

    Declaration

    Swift

    static func of(_ values: [T]) -> Gen<T>

    Parameters

    values

    The values which this generator will randomly select from

    Return Value

    The generator

Combine

  • Collects and combines the values from the generators maintaining the order

    Declaration

    Swift

    static func collect(_ generators: [Gen<T>]) -> Gen<[T]>

    Parameters

    generators

    Generators to select values from in-order

    Return Value

    The generator of Arrays containing values selected in order from the provided generators

  • Collects and combines the values from the generators maintaining the order

    Declaration

    Swift

    static func collect<R>(_ generators: [Gen<T>], _ transform: @escaping (T) -> R) -> Gen<[R]>

    Parameters

    generators

    Generators to select values from in-order

    transform

    Transformation to be applied to each value

    Return Value

    The generator of Arrays containing values selected in order from the provided generators

  • Returns: A generator which randomly selects values from either the left or right generator

    Declaration

    Swift

    static func either(left: Gen<T>, right: Gen<T>, rightProbability: Double = 0.5) -> Gen<T>

    Parameters

    left

    A generator which may get selected to produce values

    right

    A generator which may get selected to produce values

    rightProbability

    The probability that the the right generator will be selected from

    Return Value

    The generator

  • Returns: A new generator which produces strings by concatenating the elements of the generator sequence, adding the given separator between each generated element.

    Declaration

    Swift

    static func join(_ generators: [Gen<String>], separator: String = "") -> Gen<String>

    Parameters

    generators

    The generator which will be joined together to form a string

    separator

    A string to insert between each of the elements in this sequence. The default separator is an empty string

    Return Value

    The generator

  • Returns: A generator which produces values randomly selected from one of the provided generators

    Declaration

    Swift

    static func one(of generators: [Gen<T>]) -> Gen<T>

    Parameters

    generators

    The generators which can be selected from to produce a value

    Return Value

    The generator

Combine - Zip

  • Returns: A generator by zipping together the values produced by the receiver and other

    Declaration

    Swift

    func zip<R>(with other: Gen<R>) -> Gen<(T, R)>

    Parameters

    other

    Another generator to zip with

    Return Value

    A generator of Tuples

  • Returns: A generator by zipping together the values produced by the receiver and other

    Declaration

    Swift

    func zip<U, R>(with other: Gen<U>, transform: @escaping (T, U) -> R) -> Gen<R>

    Parameters

    other

    Another generator to zip with

    transform

    Transforms the values produced by the resulting zipped generator

    Return Value

    A generator of Tuples

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>
    ) -> Gen<(T1, T2)> where T == (T1, T2)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    Return Value

    A generator of Tuples

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        transform: @escaping (T1, T2) -> T
    ) -> Gen

    Parameters

    gen1

    First generator

    gen2

    Second generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2, T3>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>
    ) -> Gen<(T1, T2, T3)> where T == (T1, T2, T3)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2, T3>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        transform: @escaping (T1, T2, T3) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2, T3, T4>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>
    ) -> Gen<(T1, T2, T3, T4)> where T == (T1, T2, T3, T4)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2, T3, T4>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        transform: @escaping (T1, T2, T3, T4) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>
    ) -> Gen<(T1, T2, T3, T4, T5)> where T == (T1, T2, T3, T4, T5)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        transform: @escaping (T1, T2, T3, T4, T5) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>
    ) -> Gen<(T1, T2, T3, T4, T5, T6)> where T == (T1, T2, T3, T4, T5, T6)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    gen6

    Sixth generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        transform: @escaping (T1, T2, T3, T4, T5, T6) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    gen6

    Sixth generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>
    ) -> Gen<(T1, T2, T3, T4, T5, T6, T7)> where T == (T1, T2, T3, T4, T5, T6, T7)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    gen6

    Sixth generator

    gen7

    Seventh generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        transform: @escaping (T1, T2, T3, T4, T5, T6, T7) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Sixth generator

    gen5

    Sixth generator

    gen7

    Seventh generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7, T8>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        _ gen8: Gen<T8>
    ) -> Gen<(T1, T2, T3, T4, T5, T6, T7, T8)> where T == (T1, T2, T3, T4, T5, T6, T7, T8)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    gen6

    Sixth generator

    gen7

    Seventh generator

    gen8

    Eighth generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7, T8>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        _ gen8: Gen<T8>,
        transform: @escaping (T1, T2, T3, T4, T5, T6, T7, T8) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Sixth generator

    gen5

    Sixth generator

    gen7

    Seventh generator

    gen8

    Eighth generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        _ gen8: Gen<T8>,
        _ gen9: Gen<T9>
    ) -> Gen<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> where T == (T1, T2, T3, T4, T5, T6, T7, T8, T9)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    gen6

    Sixth generator

    gen7

    Seventh generator

    gen8

    Eighth generator

    gen9

    Ninth generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        _ gen8: Gen<T8>,
        _ gen9: Gen<T9>,
        transform: @escaping (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Sixth generator

    gen5

    Sixth generator

    gen7

    Seventh generator

    gen8

    Eighth generator

    gen9

    Ninth generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        _ gen8: Gen<T8>,
        _ gen9: Gen<T9>,
        _ gen10: Gen<T10>
    ) -> Gen<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> where T == (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Fifth generator

    gen6

    Sixth generator

    gen7

    Seventh generator

    gen8

    Eighth generator

    gen9

    Ninth generator

    gen10

    Tenth generator

    Return Value

    A generator of values

  • Returns: A generator by zipping together the values produced by the supplied generators

    Note

    This is a very complex zip operation. Perhaps you should consider using Gen.compose instead!

    Declaration

    Swift

    static func zip<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
        _ gen1: Gen<T1>,
        _ gen2: Gen<T2>,
        _ gen3: Gen<T3>,
        _ gen4: Gen<T4>,
        _ gen5: Gen<T5>,
        _ gen6: Gen<T6>,
        _ gen7: Gen<T7>,
        _ gen8: Gen<T8>,
        _ gen9: Gen<T9>,
        _ gen10: Gen<T10>,
        transform: @escaping (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> T
    ) -> Gen<T>

    Parameters

    gen1

    First generator

    gen2

    Second generator

    gen3

    Third generator

    gen4

    Fourth generator

    gen5

    Sixth generator

    gen5

    Sixth generator

    gen7

    Seventh generator

    gen8

    Eighth generator

    gen9

    Ninth generator

    gen10

    Tenth generator

    transform

    A function capable of transforming the values produced by the resulting zipped generator

    Return Value

    A generator of values

Mutate

  • Returns: The receiver’s generator expanded to generate an array of the receiver’s values

    The generated arrays will be of size size

    Declaration

    Swift

    func expand(toSize size: Int) -> Gen<[T]>

    Parameters

    size

    The size of the generated arrays

    Return Value

    A Gen generator

  • Returns: The receiver’s generator expanded to generate an array of the receiver’s values

    The generated arrays will be of random sizes in range

    Declaration

    Swift

    func expand(toSizeInRange range: Range<Int>) -> Gen<[T]>

    Parameters

    range

    A Range of values which will randomly determine the size of the generated arrays

    Return Value

    A Gen generator

  • Returns: The receiver’s generator expanded to generate an array of the receiver’s values

    The generated arrays will be of random sizes in range

    Declaration

    Swift

    func expand(toSizeInRange range: ClosedRange<Int>) -> Gen<[T]>

    Parameters

    range

    A Range of values which will randomly determine the size of the generated arrays

    Return Value

    A Gen generator

  • Returns: A generator that only produces values which pass the test isIncluded

    Warning

    If the filtered condition is rare enough this function can become infinitely complex e.g. Int.arbitrary.filter { $0 == 0 } has a 1/Int.max probability of occuring and will be nearly infinite

    Therefore if the Context’s maxDepth is reached before producing a value the generator will throw

    Declaration

    Swift

    func filter(_ isIncluded: @escaping (T) -> Bool) -> Gen<T>

    Parameters

    isIncluded

    A function which returns true if the value should be included

    maxDepth

    The maximum amount of times isIncluded may return false in succession

    Return Value

    A Gen generator.

  • Returns: A generator that transforms the receiver into a generator of type R

    Declaration

    Swift

    func flatMap<R>(_ transform: @escaping (T) -> Gen<R>) -> Gen<R>

    Parameters

    transform

    A function capable of transforming the receiver to a generator of values of type R

    Return Value

    A Gen generator of values of type R

  • Returns: A generator that transforms the receivers’ values into a value of type R

    Declaration

    Swift

    func map<R>(_ transform: @escaping (T) throws -> R) rethrows -> Gen<R>

    Parameters

    transform

    A function capable of transforming the receiver’s values to type R

    Return Value

    A Gen generator of values of type R

  • Returns: A generator that wraps the receivers’ values in an optional

    Declaration

    Swift

    func orNil(nilProbability: Double = 0.5) -> Gen<T?>

    Parameters

    nilProbability

    The probability that the optional will be nil

    Return Value

    A Gen generator

  • Returns: A generator resulting from combining generated elements from the generators sequence using the given closure

    Declaration

    Swift

    static func reduce<R>(_ generators: [Gen<T>],
                          _ initialResult: R,
                          _ nextPartialResult: @escaping (R, T) throws -> R) rethrows -> Gen<R>

    Parameters

    generators

    A sequence of generators to be reduced into a single generator instance

    initialResult

    The value to use as the initial accumulating value. initialResult is passed to nextPartialResult the first time the closure is executed.

    nextPartialResult

    A closure that combines an accumulating value and an element of the sequence into a new accumulating value, to be used in the next call of the nextPartialResult closure or returned to the caller.

    Return Value

    A Gen generator producing the final accumulated value. If the sequence has no elements, the result will be initialResult.

  • Returns: A generator of strings which replace character in source by the content of the receiver’s generator

    The receiver’s contents will be coerced by interpolation to type String

    Declaration

    Swift

    func replacingOccurrences(of substring: String, in source: String) -> Gen<String>

    Parameters

    substring

    The substring that should be replaced

    source

    The source or template String that will be modified

    Return Value

    The String generator

  • Returns: A generator of strings which modify the source by replacing all occurence of replace strings by their associated generator

    Declaration

    Swift

    static func replacing(_ source: String, with generators: [(replace: String, by: Gen<String>)]) -> Gen<String>

    Parameters

    source

    The source or template String that will be modified

    generators

    Tuple of substring to replace with associated generator

    Return Value

    The String generator

Produce

  • Returns: A Boolean value indicating whether every element of a sequence satisfies a given predicate

    Will run n times, where n is the provided iterations or the context’s value

    Declaration

    Swift

    func allSatisfy(iterations: Int? = nil,
                    context: Context = .default,
                    _ predicate: (T) throws -> Bool) rethrows -> Bool

    Parameters

    iterations

    The amount of times the sequence should iterate, default’s to the context’s maxIterations value

    context

    The context to be used for generation

    predicate

    A closure that takes an element of the sequence as its argument and returns a Boolean value that indicates whether the passed element satisfies a condition.

    Return Value

    The Boolean result

  • Iterates (lazily) over a sequence and executes a given predicate body

    Will run n times, where n is the provided iterations or the context’s value

    Declaration

    Swift

    func forEach(iterations: Int? = nil,
                 context: Context = .default,
                 _ body: (T) throws -> Void) rethrows

    Parameters

    iterations

    The amount of times the sequence should iterate, default’s to the context’s maxIterations value

    context

    The context to be used for generation

  • Returns: Non-deterministic random samples of the generator’s values

    Warning

    Recommended to be used only to evaluate or demonstrate the generator

    Declaration

    Swift

    func samples(count: Int = 20) -> [T]

    Parameters

    count

    The amount of values to be returned as samples

    Return Value

    An array of sample values

  • Returns: A single non-deterministic random sample of the generator’s values

    Warning

    Recommended to be used only to evaluate or demonstrate the generator

    Declaration

    Swift

    func sample() -> T

    Return Value

    A sample value

  • Returns: An array of values from the generator

    Declaration

    Swift

    func take(count: Int? = nil,
              context: Context = .default) -> [T]

    Parameters

    count

    The amount of values to generate, default’s to the context’s iterations value

    context

    The context to be used for generation

    Return Value

    An array of generated values

Available where T: CaseIterable

  • Adapts a type conforming to CaseIterable into a generator which produces values of any case

    Precondition

    The receiver’s allCases property must not return empty

    Declaration

    Swift

    static func ofCases() -> Gen<T>

    Return Value

    A generator capable of generating any of the receiver’s cases

Available where T: RandomInRangeable

  • Returns: A generator which produces elements in the provided range

    Declaration

    Swift

    static func from(_ range: Range<T>) -> Gen

    Parameters

    range

    The range in which the generator will randomly select values

    Return Value

    The generator

  • Returns: A generator which produces elements in the provided range

    Declaration

    Swift

    static func from(_ range: ClosedRange<T>) -> Gen

    Parameters

    range

    The range in which the generator will randomly select values

    Return Value

    The generator

Available where T: Equatable

  • Returns: A generator that only produces unique values

    Warning

    If the unique’d Generator is small enough this function will throw UniqueError.maxDepthReached

    Therefore if the Context’s maxDepth is reached before producing a value the generator will throw

    Warning

    The unique cache will persist between uses with the same Context, leading to a higher chance of exhausting the generator

    The Context‘s unique cache may be cleared by calling Context.clearCache()

    Declaration

    Swift

    func unique() -> Gen<T>

    Parameters

    maxDepth

    The maximum amount of times we will attempt to create a distinct unique value before throwing

    Return Value

    A Gen generator.