Variable parameterizedLaws`Const`

parameterizedLaws: {
    Alternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<AlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
    Applicative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ApplicativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
    Bicovariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<BicovariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet);
    Contravariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ContravariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
    Covariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<CovariantTypeLambda, F, A, B, C, In1, Out2, Out1>, suffix?: string) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
    Invariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<InvariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
    Monad: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<MonadTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet);
    SemiAlternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<SemiAlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
    Traversable: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<TraversableTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    });
} = ...

Map of typeclass name to their laws, for typeclasses of parameterized types.

Type declaration

ReadonlyAlternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<AlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Typeclass laws for Alternative.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<AlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]
ReadonlyApplicative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ApplicativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Test typeclass laws for Applicative.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<ApplicativeTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]
ReadonlyBicovariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<BicovariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet)
- - <F, A, B, C, In1, Out2, Out1>(given): LawSet
  - Test typeclass laws for Bicovariant.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<BicovariantTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns LawSet
ReadonlyContravariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ContravariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Test typeclass laws for Contravariant and its requirement: Invariant.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<ContravariantTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]
ReadonlyCovariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<CovariantTypeLambda, F, A, B, C, In1, Out2, Out1>, suffix?: string) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given, suffix?): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Test typeclass laws for Covariant.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<CovariantTypeLambda, F, A, B, C, In1, Out2, Out1>
    - Optionalsuffix: string
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]
ReadonlyInvariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<InvariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Test typeclass laws for Invariant.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<InvariantTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]
ReadonlyMonad: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<MonadTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet)
- - <F, A, B, C, In1, Out2, Out1>(given): LawSet
  - Test typeclass laws for Monad.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<MonadTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns LawSet
ReadonlySemiAlternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<SemiAlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Test typeclass laws for SemiAlternative.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<SemiAlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]
ReadonlyTraversable: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<TraversableTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
    laws: Law<any>[];
    name?: string;
    sets: LawSet[];
})
- - <F, A, B, C, In1, Out2, Out1>(given): {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
  - Test typeclass laws for Traversable.
    Type Parameters
    - F extends TypeLambda
    - A
    - B = A
    - C = A
    - In1 = never
    - Out2 = unknown
    - Out1 = unknown
    Parameters
    - given: ParameterizedGiven<TraversableTypeLambda, F, A, B, C, In1, Out2, Out1>
    Returns {
        laws: Law<any>[];
        name?: string;
        sets: LawSet[];
    }
    - laws: Law<any>[]
      Possibly empty list laws that must pass for the law set to pass.
    - Optionalname?: string
      Optional name of unit under test. Runner uses this for describe() block name. If missing, no describe() block is wrapped around child laws.
    - sets: LawSet[]

Variable parameterizedLawsConst

Type declaration

ReadonlyAlternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<AlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

ReadonlyApplicative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ApplicativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

ReadonlyBicovariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<BicovariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet)

Type Parameters

Parameters

Returns LawSet

ReadonlyContravariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ContravariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

ReadonlyCovariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<CovariantTypeLambda, F, A, B, C, In1, Out2, Out1>, suffix?: string) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

ReadonlyInvariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<InvariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

ReadonlyMonad: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<MonadTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet)

Type Parameters

Parameters

Returns LawSet

ReadonlySemiAlternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<SemiAlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

ReadonlyTraversable: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<TraversableTypeLambda, F, A, B, C, In1, Out2, Out1>) => { laws: Law<any>[]; name?: string; sets: LawSet[]; })

Type Parameters

Parameters

Returns { laws: Law<any>[]; name?: string; sets: LawSet[]; }

laws: Law<any>[]

Optionalname?: string

sets: LawSet[]

Settings

Variable parameterizedLaws`Const`

`Readonly`Alternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<AlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string

`Readonly`Applicative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ApplicativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string

`Readonly`Bicovariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<BicovariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet)

`Readonly`Contravariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<ContravariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string

`Readonly`Covariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<CovariantTypeLambda, F, A, B, C, In1, Out2, Out1>, suffix?: string) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string

`Readonly`Invariant: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<InvariantTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string

`Readonly`Monad: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<MonadTypeLambda, F, A, B, C, In1, Out2, Out1>) => LawSet)

`Readonly`SemiAlternative: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<SemiAlternativeTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string

`Readonly`Traversable: (<F, A, B, C, In1, Out2, Out1>(given: ParameterizedGiven<TraversableTypeLambda, F, A, B, C, In1, Out2, Out1>) => {
laws: Law<any>[];
name?: string;
sets: LawSet[];
})

Returns {
laws: Law<any>[];
name?: string;
sets: LawSet[];
}

`Optional`name?: string