Interface MonadReader<R, 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

R
M

Hierarchy

Monad<M>
- MonadReader

Index

Properties

apply ask flatMap local map pure

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` ask

ask: (() => Get1<M, R>)

Type declaration

- (): Get1<M, R>
- Returns Get1<M, R>

`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` local

local: ((modifier) => (<A>(m) => Get1<M, A>))

Type declaration

- (modifier): (<A>(m) => Get1<M, A>)
- Parameters
  - modifier: ((record) => R)
    - (record): R
      Parameters
      record: R
      Returns R
  Returns (<A>(m) => Get1<M, A>)
  - - <A>(m): Get1<M, A>
    - Type Parameters
      A
      Parameters
      m: Get1<M, A>
      Returns Get1<M, A>

`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>>

Generated using TypeDoc