Apropos

Fast strong typed 'Either' data structure for typescript and flow

$ npm install --save apropos

API

• of
• ofL
• Right
• Left
• is
• makeError

//@flow

import defaultOf, {
  of,
  ofL,
  Right,
  Left,
  is,
  makeError,
  type Apropos,
  type MakeError,
} from 'apropos'

of

function of<R>(value: R): Apropos<void, R>

Create pure right-handed value, left-handed type is empty. Exports by default

ofL

function ofL<L>(value: L): Apropos<L, void>

Create pure left-handed value, right-handed type is empty.

Right

function Right<-L, R>(value: R): Apropos<L, R>

Create right-handed value, left-handed type is inferred from usage. Technically, Right returns the same as of; the difference is only in the type inference.

Left

function Left<L, -R>(value: L): Apropos<L, R>

Create left-handed value, right-handed type is inferred from usage

is

function is<-T>(value: T): boolean

Checks whether an object is an instance of Apropos

makeError

class AnnotatedError<Context, Tag> extends Error {
  tag: Tag
  data: Context
}

function makeError<-Tag>(tag: Tag): <Context>(data: Context) => AnnotatedError<Context, Tag>

Create fabric for generating tagged error constructors. Useful in .mapL.

See annotated errors

Instance methods

• isRight

• isLeft

• equals

• thru

• orElse

• swap

• promise

• fold

Maps

• map

• mapR

• mapL

• bimap

Taps

• tap

• tapR

• tapL

• bitap

Chains

• chain

• chainR

• chainL

• bichain

Conditions

• cond

• chainCond

• logic

Combinations

• alt

• and

• ap

Annotated errors

import { of, makeError, MakeError, Left } from 'apropos'

const notNumber: MakeError<'Not a number'> = makeError('Not a number')
const isNegative: MakeError<'Negative number'> = makeError('Negative number')

const positiveNum =
  of(-2)
    .map(x => x + 1)
    .chain(x => typeof x === 'number'
      ? of(x)
      : Left(x))
    .mapL(notNumber)
    .logic({
      cond: x => x > 0,
      pass: x => 'Positive number: ' + x,
      fail: isNegative
    })

positiveNum.fold(x => console.log(x), x => console.error(x))

// => Annotated Error: 'Negative number' -1

The project is released under the Mit License