effect-ts-laws
    Preparing search index...

    Variable Law

    Law: <Ts extends UnknownArgs>(
        name: string,
        note: string,
        ...arbitraries: { [K in string | number | symbol]: Arbitrary<Ts[K<K>]> },
    ) => (
        predicate: (...args: Ts) => boolean,
        parameters?: ParameterOverrides,
    ) => Law<Ts>

    Build a law from a name, a predicate, an optional note, an arbitrary for the predicate arguments, and optional fast-check runtime parameters. The runtime parameters are documented here.

    Type declaration

      • <Ts extends UnknownArgs>(
            name: string,
            note: string,
            ...arbitraries: { [K in string | number | symbol]: Arbitrary<Ts[K<K>]> },
        ): (
            predicate: (...args: Ts) => boolean,
            parameters?: ParameterOverrides,
        ) => Law<Ts>

      • Type Parameters

        • Ts extends UnknownArgs

          Argument type of predicate. For example, if the law predicate signature is Predicate<[a: number, b: string]>, then T would be [a: number, b: string].

        Parameters

        • name: string

          Law name, shown as test label.

        • note: string

          String note to be shown on failure or in verbose mode.

        • ...arbitraries: { [K in string | number | symbol]: Arbitrary<Ts[K<K>]> }

          A tuple of arbitraries, one per predicate argument.

        Returns (
            predicate: (...args: Ts) => boolean,
            parameters?: ParameterOverrides,
        ) => Law<Ts>

          • (predicate: (...args: Ts) => boolean, parameters?: ParameterOverrides): Law<Ts>

          • Parameters

            • predicate: (...args: Ts) => boolean

              Law predicate. Its argument type is encoded in Ts.

            • Optionalparameters: ParameterOverrides

              fast-check runtime parameters.

            Returns Law<Ts>

    import {Law, checkLaw, tinyPositive} from 'effect-ts-laws'
    import {Option as OP} from 'effect'

    export const law: Law<[number, number]> = Law(
      'sum of positives ≥ both',           // • law name
      '∀a,b in N, sum=a+b: sum≥a ∧ sum≥b', // • law note
      tinyPositive,                        // • list of
      tinyPositive,                        //   arbitraries that
    )(                                     //   are required for...
      (x, y) => x + y >= x && x + y >= y,  // • the law predicate
      {numRuns: 10_000},                   // • optional runtime config
    )

    assert.equal(law.name, 'sum of positives ≥ both')
    assert.deepStrictEqual(checkLaw(law), OP.none())

    Settings

    Member Visibility