MonadLaws | funfix-types

Type class laws defined for Monad.

This is an abstract definition. In order to use it in unit testing, the implementor must think of a strategy to evaluate the truthiness of the returned Equiv values.

Even though in TypeScript the Funfix library is using classes to express these laws, when implementing this class it is recommended that you implement it as a mixin using implements, instead of extending it directly with extends. See TypeScript: Mixins for details and note that we already have applyMixins defined.

We are doing this in order to support multiple inheritance and to avoid inheriting any static members. In the Flow definitions (e.g. .js.flow files) for Funfix these classes are defined with interface, as they are meant to be interfaces that sometimes have default implementations and not classes.

Type parameters

Hierarchy

MonadLaws

Implements

ApplicativeLaws<F>
FlatMapLaws<F>

Implemented by

MonadErrorLaws

Properties

F

F: Monad<F>

The Monad designated instance for F, to be tested.

applicativeComposition

applicativeComposition: function

Mixed-in from ApplicativeLaws.applicativeComposition.

Type declaration

- <A, B, C>(fa: HK<F, A>, fab: HK<F, function>, fbc: HK<F, function>): Equiv<HK<F, C>>
- Type parameters
  - A
  - B
  - C
  Parameters
  - fa: HK<F, A>
  - fab: HK<F, function>
  - fbc: HK<F, function>
  Returns Equiv<HK<F, C>>

applicativeHomomorphism

applicativeHomomorphism: function

Mixed-in from ApplicativeLaws.applicativeHomomorphism.

Type declaration

- <A, B>(a: A, f: function): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - a: A
  - f: function
    - - (a: A): B
      - Parameters
        
        a: A
        
        Returns B
  Returns Equiv<HK<F, B>>

applicativeIdentity

applicativeIdentity: function

Mixed-in from ApplicativeLaws.applyComposition.

Type declaration

- <A>(fa: HK<F, A>): Equiv<HK<F, A>>
- Type parameters
  - A
  Parameters
  - fa: HK<F, A>
  Returns Equiv<HK<F, A>>

applicativeInterchange

applicativeInterchange: function

Mixed-in from ApplicativeLaws.applicativeInterchange.

Type declaration

- <A, B>(a: A, ff: HK<F, function>): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - a: A
  - ff: HK<F, function>
  Returns Equiv<HK<F, B>>

applicativeMap

applicativeMap: function

Mixed-in from ApplicativeLaws.applicativeMap.

Type declaration

- <A, B>(fa: HK<F, A>, f: function): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - f: function
    - - (a: A): B
      - Parameters
        
        a: A
        
        Returns B
  Returns Equiv<HK<F, B>>

applicativeUnit

applicativeUnit: function

Mixed-in from ApplicativeLaws.applicativeUnit.

Type declaration

- <A>(a: A): Equiv<HK<F, A>>
- Type parameters
  - A
  Parameters
  - a: A
  Returns Equiv<HK<F, A>>

applyComposition

applyComposition: function

Mixed-in from ApplyLaws.applyComposition.

Type declaration

- <A, B, C>(fa: HK<F, A>, fab: HK<F, function>, fbc: HK<F, function>): Equiv<HK<F, C>>
- Type parameters
  - A
  - B
  - C
  Parameters
  - fa: HK<F, A>
  - fab: HK<F, function>
  - fbc: HK<F, function>
  Returns Equiv<HK<F, C>>

applyMap2Consistency

applyMap2Consistency: function

Mixed-in from ApplyLaws.applyMap2Consistency.

Type declaration

- <A, B>(fa: HK<F, A>, f: HK<F, function>): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - f: HK<F, function>
  Returns Equiv<HK<F, B>>

applyProductConsistency

applyProductConsistency: function

Mixed-in from ApplyLaws.applyProductConsistency.

Type declaration

- <A, B>(fa: HK<F, A>, f: HK<F, function>): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - f: HK<F, function>
  Returns Equiv<HK<F, B>>

covariantComposition

covariantComposition: function

Mixed-in from FunctorLaws.covariantComposition.

Type declaration

- <A, B, C>(fa: HK<F, A>, f: function, g: function): Equiv<HK<F, C>>
- Type parameters
  - A
  - B
  - C
  Parameters
  - fa: HK<F, A>
  - f: function
    - - (a: A): B
      - Parameters
        
        a: A
        
        Returns B
  - g: function
    - - (b: B): C
      - Parameters
        
        b: B
        
        Returns C
  Returns Equiv<HK<F, C>>

covariantIdentity

covariantIdentity: function

Mixed-in from FunctorLaws.covariantIdentity.

Type declaration

- <A>(fa: HK<F, A>): Equiv<HK<F, A>>
- Type parameters
  - A
  Parameters
  - fa: HK<F, A>
  Returns Equiv<HK<F, A>>

flatMapAssociativity

flatMapAssociativity: function

Mixed-in from FlatMapLaws.flatMapAssociativity.

Type declaration

- <A, B, C>(fa: HK<F, A>, f: function, g: function): Equiv<HK<F, C>>
- Type parameters
  - A
  - B
  - C
  Parameters
  - fa: HK<F, A>
  - f: function
    - - (a: A): HK<F, B>
      - Parameters
        
        a: A
        
        Returns HK<F, B>
  - g: function
    - - (b: B): HK<F, C>
      - Parameters
        
        b: B
        
        Returns HK<F, C>
  Returns Equiv<HK<F, C>>

flatMapConsistentApply

flatMapConsistentApply: function

Mixed-in from FlatMapLaws.flatMapConsistentApply.

Type declaration

- <A, B>(fa: HK<F, A>, fab: HK<F, function>): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - fab: HK<F, function>
  Returns Equiv<HK<F, B>>

followedByConsistency

followedByConsistency: function

Mixed-in from FlatMapLaws.followedByConsistency.

Type declaration

- <A, B>(fa: HK<F, A>, fb: HK<F, B>): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - fb: HK<F, B>
  Returns Equiv<HK<F, B>>

followedByLConsistency

followedByLConsistency: function

Mixed-in from FlatMapLaws.followedByLConsistency.

Type declaration

- <A, B>(fa: HK<F, A>, fb: HK<F, B>): Equiv<HK<F, B>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - fb: HK<F, B>
  Returns Equiv<HK<F, B>>

forEffectConsistency

forEffectConsistency: function

Mixed-in from FlatMapLaws.forEffectConsistency.

Type declaration

- <A, B>(fa: HK<F, A>, fb: HK<F, B>): Equiv<HK<F, A>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - fb: HK<F, B>
  Returns Equiv<HK<F, A>>

forEffectLConsistency

forEffectLConsistency: function

Mixed-in from FlatMapLaws.forEffectLConsistency.

Type declaration

- <A, B>(fa: HK<F, A>, fb: HK<F, B>): Equiv<HK<F, A>>
- Type parameters
  - A
  - B
  Parameters
  - fa: HK<F, A>
  - fb: HK<F, B>
  Returns Equiv<HK<F, A>>

tailRecMConsistentFlatMap

tailRecMConsistentFlatMap: function

Mixed-in from FlatMapLaws.tailRecMConsistentFlatMap.

Type declaration

- <A>(a: A, f: function): Equiv<HK<F, A>>
- Type parameters
  - A
  Parameters
  - a: A
  - f: function
    - - (a: A): HK<F, A>
      - Parameters
        
        a: A
        
        Returns HK<F, A>
  Returns Equiv<HK<F, A>>

Methods

mapFlatMapCoherence

mapFlatMapCoherence<A, B>(fa: HK<F, A>, f: function): Equiv<HK<F, B>>

- Defined in monad.ts:578
Type parameters
- A
- B
Parameters
- fa: HK<F, A>
- f: function
  - - (a: A): B
    - Parameters
      - a: A
      Returns B
Returns Equiv<HK<F, B>>

monadLeftIdentity

monadLeftIdentity<A, B>(a: A, f: function): Equiv<HK<F, B>>

- Defined in monad.ts:568
Type parameters
- A
- B
Parameters
- a: A
- f: function
  - - (a: A): HK<F, B>
    - Parameters
      - a: A
      Returns HK<F, B>
Returns Equiv<HK<F, B>>

monadRightIdentity

monadRightIdentity<A, B>(fa: HK<F, A>): Equiv<HK<F, A>>

- Defined in monad.ts:573
Type parameters
- A
- B
Parameters
- fa: HK<F, A>
Returns Equiv<HK<F, A>>

tailRecMStackSafety

tailRecMStackSafety(): Equiv<HK<F, number>>

- Defined in monad.ts:583
Returns Equiv<HK<F, number>>

Generated using TypeDoc

Type parameters

F

Hierarchy

Implements

Implemented by

Index

Properties

Methods

Properties

F

applicativeComposition

Type declaration

Type parameters

A

B

C

Parameters

fa: HK<F, A>

fab: HK<F, function>

fbc: HK<F, function>

Returns Equiv<HK<F, C>>

applicativeHomomorphism

Type declaration

Type parameters

A

B

Parameters

a: A

f: function

Parameters

a: A

Returns B

Returns Equiv<HK<F, B>>

applicativeIdentity

Type declaration

Type parameters

A

Parameters

fa: HK<F, A>

Returns Equiv<HK<F, A>>

applicativeInterchange

Type declaration

Type parameters

A

B

Parameters

a: A

ff: HK<F, function>

Returns Equiv<HK<F, B>>

applicativeMap

Type declaration

Type parameters

A

B

Parameters

fa: HK<F, A>

f: function

Parameters

a: A

Returns B

Returns Equiv<HK<F, B>>

applicativeUnit

Type declaration

Type parameters

A

Parameters

a: A

Returns Equiv<HK<F, A>>

applyComposition

Type declaration

Type parameters

A

B

C

Parameters

fa: HK<F, A>

fab: HK<F, function>

fbc: HK<F, function>

Returns Equiv<HK<F, C>>

applyMap2Consistency