Interface MonadState<S, M>

A sequential computation framework with wrapping the type S. All instances of the monad m must satisfy the following laws:

Left identity: For all f and a; m.flatMap(f)(m.pure(a)) equals to f(a),
Right identity: For all a; m.flatMap(m.pure)(a) equals to a,
Associativity: For all f, g and a; m.flatMap(f)(m.flatMap(g)(a)) equals to m.flatMap((x) => m.flatMap(f)(g(x)))(a).

Type Parameters

S
M

Hierarchy

Monad<M>
- MonadState

Index

Properties

apply flatMap map pure state

Properties

`Readonly` apply

apply: (<T, U>(fn) => ((t) => Instance<Apply1<M, U>>))

Type declaration

- <T, U>(fn): ((t) => Instance<Apply1<M, U>>)
- Applies the function to the value over S.
  Type Parameters
  - T
  - U
  Parameters
  - fn: Instance<Apply1<M, ((t) => U)>>
    The wrapped function.
  Returns ((t) => Instance<Apply1<M, U>>)
  The value got by evaluating fn.
  - - (t): Instance<Apply1<M, U>>
    - Parameters
      t: Instance<Apply1<M, T>>
      Returns Instance<Apply1<M, U>>

`Readonly` flatMap

flatMap: (<T1, U1>(a) => ((t) => Instance<Apply1<M, U1>>))

Type declaration

- <T1, U1>(a): ((t) => Instance<Apply1<M, U1>>)
- Type Parameters
  - T1
  - U1
  Parameters
  - a: ((t) => Instance<Apply1<M, U1>>)
    - (t): Instance<Apply1<M, U1>>
      Parameters
      t: T1
      Returns Instance<Apply1<M, U1>>
  Returns ((t) => Instance<Apply1<M, U1>>)
  - - (t): Instance<Apply1<M, U1>>
    - Parameters
      t: Instance<Apply1<M, T1>>
      Returns Instance<Apply1<M, U1>>

`Readonly` map

map: (<T, U>(fn) => ((t) => Instance<Apply1<M, U>>))

Type declaration

- <T, U>(fn): ((t) => Instance<Apply1<M, U>>)
- Maps the function fn onto F structure.
  Type Parameters
  - T
  - U
  Parameters
  - fn: ((t) => U)
    The function to be mapped.
    - (t): U
      Parameters
      t: T
      Returns U
  Returns ((t) => Instance<Apply1<M, U>>)
  The mapped function.
  - - (t): Instance<Apply1<M, U>>
    - Parameters
      t: Instance<Apply1<M, T>>
      Returns Instance<Apply1<M, U>>

`Readonly` pure

pure: (<T>(t) => Instance<Apply1<M, T>>)

Type declaration

- <T>(t): Instance<Apply1<M, T>>
- Type Parameters
  - T
  Parameters
  - t: T
  Returns Instance<Apply1<M, T>>

`Readonly` state

state: (<A>(modifier) => Get1<M, A>)

Type declaration

- <A>(modifier): Get1<M, A>
- Type Parameters
  - A
  Parameters
  - modifier: ((state) => [A, S])
    - (state): [A, S]
      Parameters
      state: S
      Returns [A, S]
  Returns Get1<M, A>

Generated using TypeDoc