"node_modules/fp-ts/lib/Either.d"

Index

Classes

Type aliases

Either

Variables

Type aliases

Either

Either: Left<L, A> | Right<L, A>

Variables

URI

URI: "Either" = "Either"

alt

alt: function

Type declaration

- <L, A>(fx: Either<L, A>): function
- Type parameters
  - L
  - A
  Parameters
  - fx: Either<L, A>
  Returns function
  - - (fy: Either<L, A>): Either<L, A>
    - Parameters
      - fy: Either<L, A>
      Returns Either<L, A>

ap

ap: function

Type declaration

- <L, A, B>(fab: Either<L, function>, fa: Either<L, A>): Either<L, B>
- Type parameters
  - L
  - A
  - B
  Parameters
  - fab: Either<L, function>
  - fa: Either<L, A>
  Returns Either<L, B>

bimap

bimap: function

Type declaration

- <L, V, A, B>(f: function, g: function): function
- Type parameters
  - L
  - V
  - A
  - B
  Parameters
  - f: function
    - - (u: L): V
      - Parameters
        
        u: L
        
        Returns V
  - g: function
    - - (a: A): B
      - Parameters
        
        a: A
        
        Returns B
  Returns function
  - - (fau: Either<L, A>): Either<V, B>
    - Parameters
      - fau: Either<L, A>
      Returns Either<V, B>

chain

chain: function

Type declaration

- <L, A, B>(f: function, fa: Either<L, A>): Either<L, B>
- Type parameters
  - L
  - A
  - B
  Parameters
  - f: function
    - - (a: A): Either<L, B>
      - Parameters
        
        a: A
        
        Returns Either<L, B>
  - fa: Either<L, A>
  Returns Either<L, B>

chainRec

chainRec: function

Type declaration

- <L, A, B>(f: function, a: A): Either<L, B>
- Type parameters
  - L
  - A
  - B
  Parameters
  - f: function
    - - (a: A): Either<L, Either<A, B>>
      - Parameters
        
        a: A
        
        Returns Either<L, Either<A, B>>
  - a: A
  Returns Either<L, B>

either

either: Monad<URI> & Foldable<URI> & Traversable<URI> & Bifunctor<URI> & Alt<URI> & Extend<URI> & ChainRec<URI>

equals

equals: function

Type declaration

- <L, A>(SL: Setoid<L>, SA: Setoid<A>): function
- Type parameters
  - L
  - A
  Parameters
  - SL: Setoid<L>
  - SA: Setoid<A>
  Returns function
  - - (fx: Either<L, A>): function
    - Parameters
      - fx: Either<L, A>
      Returns function
      - (fy: Either<L, A>): boolean
        
        Parameters
        
        fy: Either<L, A>
        
        Returns boolean

extend

extend: function

Type declaration

- <L, A, B>(f: function, ea: Either<L, A>): Either<L, B>
- Type parameters
  - L
  - A
  - B
  Parameters
  - f: function
    - - (ea: Either<L, A>): B
      - Parameters
        
        ea: Either<L, A>
        
        Returns B
  - ea: Either<L, A>
  Returns Either<L, B>

fold

fold: function

Type declaration

- <L, A, B>(left: function, right: function, fa: Either<L, A>): B
- Type parameters
  - L
  - A
  - B
  Parameters
  - left: function
    - - (l: L): B
      - Parameters
        
        l: L
        
        Returns B
  - right: function
    - - (a: A): B
      - Parameters
        
        a: A
        
        Returns B
  - fa: Either<L, A>
  Returns B

fromNullable

fromNullable: function

Takes a default and a nullable value, if the value is not nully, turn it into a Right, if the value is nully use the provided default as a Left

Type declaration

- <L>(defaultValue: L): function
- Type parameters
  - L
  Parameters
  - defaultValue: L
  Returns function
  - - <A>(a: A | null | undefined): Either<L, A>
    - Type parameters
      - A
      Parameters
      - a: A | null | undefined
      Returns Either<L, A>

fromOption

fromOption: function

Takes a default and a Option value, if the value is a Some, turn it into a Right, if the value is a None use the provided default as a Left

Type declaration

- <L>(defaultValue: L): function
- Type parameters
  - L
  Parameters
  - defaultValue: L
  Returns function
  - - <A>(fa: Option<A>): Either<L, A>
    - Type parameters
      - A
      Parameters
      - fa: Option<A>
      Returns Either<L, A>

fromPredicate

fromPredicate: function

Type declaration

- <L, A>(predicate: Predicate<A>, l: function): function
- Type parameters
  - L
  - A
  Parameters
  - predicate: Predicate<A>
  - l: function
    - - (a: A): L
      - Parameters
        
        a: A
        
        Returns L
  Returns function
  - - (a: A): Either<L, A>
    - Parameters
      - a: A
      Returns Either<L, A>

getFilterable

getFilterable: function

Type declaration

- <M>(M: Monoid<M>): Filterable<"Either">
- Type parameters
  - M
  Parameters
  - M: Monoid<M>
  Returns Filterable<"Either">

getOrElse

getOrElse: function

Returns the value from this Right or the given argument if this is a Left

Type declaration

- <L, A>(f: function): function
- Type parameters
  - L
  - A
  Parameters
  - f: function
    - - (l: L): A
      - Parameters
        
        l: L
        
        Returns A
  Returns function
  - - (fa: Either<L, A>): A
    - Parameters
      - fa: Either<L, A>
      Returns A

getOrElseValue

getOrElseValue: function

Type declaration

- <A>(value: A): function
- Type parameters
  - A
  Parameters
  - value: A
  Returns function
  - - <L>(fa: Either<L, A>): A
    - Type parameters
      - L
      Parameters
      - fa: Either<L, A>
      Returns A

getSetoid

getSetoid: function

Type declaration

- <L, A>(SL: Setoid<L>, SA: Setoid<A>): Setoid<Either<L, A>>
- Type parameters
  - L
  - A
  Parameters
  - SL: Setoid<L>
  - SA: Setoid<A>
  Returns Setoid<Either<L, A>>

getWitherable

getWitherable: function

Type declaration

- <M>(monoid: Monoid<M>): Witherable<"Either">
- Type parameters
  - M
  Parameters
  - monoid: Monoid<M>
  Returns Witherable<"Either">

isLeft

isLeft: function

Type declaration

- <L, A>(fa: Either<L, A>): boolean
- Type parameters
  - L
  - A
  Parameters
  - fa: Either<L, A>
  Returns boolean

isRight

isRight: function

Type declaration

- <L, A>(fa: Either<L, A>): boolean
- Type parameters
  - L
  - A
  Parameters
  - fa: Either<L, A>
  Returns boolean

left

left: function

Type declaration

- <L, A>(l: L): Either<L, A>
- Type parameters
  - L
  - A
  Parameters
  - l: L
  Returns Either<L, A>

map

map: function

Type declaration

- <L, A, B>(f: function, fa: Either<L, A>): Either<L, B>
- Type parameters
  - L
  - A
  - B
  Parameters
  - f: function
    - - (a: A): B
      - Parameters
        
        a: A
        
        Returns B
  - fa: Either<L, A>
  Returns Either<L, B>

mapLeft

mapLeft: function

Type declaration

- <L, M>(f: function): function
- Type parameters
  - L
  - M
  Parameters
  - f: function
    - - (l: L): M
      - Parameters
        
        l: L
        
        Returns M
  Returns function
  - - <A>(fa: Either<L, A>): Either<M, A>
    - Type parameters
      - A
      Parameters
      - fa: Either<L, A>
      Returns Either<M, A>

of

of: function

Type declaration

- <L, A>(a: A): Either<L, A>
- Type parameters
  - L
  - A
  Parameters
  - a: A
  Returns Either<L, A>

reduce

reduce: function

Type declaration

- <L, A, B>(f: function, b: B, fa: Either<L, A>): B
- Type parameters
  - L
  - A
  - B
  Parameters
  - f: function
    - - (b: B, a: A): B
      - Parameters
        
        b: B
        
        a: A
        
        Returns B
  - b: B
  - fa: Either<L, A>
  Returns B

right

right: function

Type declaration

- <L, A>(a: A): Either<L, A>
- Type parameters
  - L
  - A
  Parameters
  - a: A
  Returns Either<L, A>

toOption

toOption: function

Type declaration

- <L, A>(fa: Either<L, A>): Option<A>
- Type parameters
  - L
  - A
  Parameters
  - fa: Either<L, A>
  Returns Option<A>

traverse

traverse: traverse

tryCatch

tryCatch: function

Type declaration

- <A>(f: Lazy<A>): Either<Error, A>
- Type parameters
  - A
  Parameters
  - f: Lazy<A>
  Returns Either<Error, A>

Index

Classes

Type aliases

Variables

Type aliases

Either

Variables

URI

alt

Type declaration

Type parameters

L

A

Parameters

fx: Either<L, A>

Returns function

Parameters

fy: Either<L, A>

Returns Either<L, A>

ap

Type declaration

Type parameters

L

A

B

Parameters

fab: Either<L, function>

fa: Either<L, A>

Returns Either<L, B>

bimap

Type declaration

Type parameters

L

V

A

B

Parameters

f: function

Parameters

u: L

Returns V

g: function

Parameters

a: A

Returns B

Returns function

Parameters

fau: Either<L, A>

Returns Either<V, B>

chain

Type declaration

Type parameters

L

A

B

Parameters

f: function

Parameters

a: A

Returns Either<L, B>

fa: Either<L, A>

Returns Either<L, B>

chainRec

Type declaration

Type parameters

L

A

B

Parameters

f: function

Parameters

a: A

Returns Either<L, Either<A, B>>

a: A

Returns Either<L, B>

either

equals

Type declaration

Type parameters

L