Apropos

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

$ npm install --save apropos

npm version Build Status

API

//@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.

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

Apropos

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

Apropos Info

⭐ Stars 20
🔗 Source Code github.com
🕒 Last Update 8 months ago
🕒 Created 4 years ago
🐞 Open Issues 0
➗ Star-Issue Ratio Infinity
😎 Author zerobias