Interface MonadPlus<M>

A monad with monoid-ish combine operation.

interface MonadPlus<M> {
    alt: <A>(
        first: Instance<Apply1<M, A>>,
    ) => (second: Instance<Apply1<M, A>>) => Instance<Apply1<M, A>>;
    apply: <T, U>(
        fn: Instance<Apply1<M, (t: T) => U>>,
    ) => (t: Instance<Apply1<M, T>>) => Instance<Apply1<M, U>>;
    empty: <A>() => Instance<Apply1<M, A>>;
    flatMap: <T1, U1>(
        a: (t: T1) => Instance<Apply1<M, U1>>,
    ) => (t: Instance<Apply1<M, T1>>) => Instance<Apply1<M, U1>>;
    map: <T, U>(
        fn: (t: T) => U,
    ) => (t: Instance<Apply1<M, T>>) => Instance<Apply1<M, U>>;
    pure: <T>(t: T) => Instance<Apply1<M, T>>;
}

Type Parameters

M

Hierarchy (View Summary)

TypeClass.Monad.Monad<M>
TypeClass.Alternative.Alternative<M>
- MonadPlus

Index

Properties

alt apply empty flatMap map pure

Properties

`Readonly`alt

alt: <A>(
first: Instance<Apply1<M, A>>,
) => (second: Instance<Apply1<M, A>>) => Instance<Apply1<M, A>>

Picks the first successful computation.

Type Declaration

- <A>(
  first: Instance<Apply1<M, A>>,
  ): (second: Instance<Apply1<M, A>>) => Instance<Apply1<M, A>>
- Type Parameters
  - A
  Parameters
  - first: Instance<Apply1<M, A>>
    The first computation to attempt.
  Returns (second: Instance<Apply1<M, A>>) => Instance<Apply1<M, A>>
  The first successful computation.

`Readonly`apply

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

Applies the function to the value over S.

Type Declaration

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

`Readonly`empty

empty: <A>() => Instance<Apply1<M, A>>

Creates an empty erroneous computation that exits early.

`Readonly`flatMap

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

`Readonly`map

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

Maps the function fn onto F structure.

Type Declaration

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

`Readonly`pure

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