kojima

a small functional/monad library

Usage

Example

import { Option, Some, None, Result, Ok, Err } from 'kojima'

const maybe = Option.of('thing')
maybe.isSome() // true
const isnt = maybe.chain(None).map(_x => 'other') // None
isnt.isSome() // false

const result = Result.of('3:41am')
result.isOk() // true

result.chain(() => Err(new Error(-Infinity)))
    .map(_x => '4:10am')
    .chain(Ok)

result.isErr() // true

// crimes!
None == None() // true

Documentation

curry

(* -> a) -> (* -> a)

Returns a curried equivalent of the provided function.

import { curry } from './curry.js'

const add = (a, b, c) => a + b + c
const curriedAdd = curry(add)
const add1 = curriedAdd(1)
const add3 = add1(2)
const add4 = curriedAdd(2, 2)

const six = add3(3) // 6
const eight = add4(2) // 7
const twelve = curriedAdd(4, 4, 4) // 12

Option

Represents a value which may not exist.

Methods

of :: Option f => a -> f a

Option.of<a>(value: a) -> Option<a>

zero :: Option f => () -> f a

Option.zero<a>(value: a) -> Option<a>

chain :: Option m => m a ~> (a -> m b) -> m b

Option<T>.chain<U>(fn: (value: T) -> Option<U>) -> Option<U>

map :: Option f => f a ~> (a -> b) -> f b

Option<T>.map<U>(fn: (value: T) -> U) -> Option<U>

alt :: Option f => f a ~> f a -> f a

Option<T>.alt(other: Option<T>) -> Option<T>

fold :: Option f => f a ~> ((b, a) -> b, b) -> b

Option<T>.fold<U>(fn: ((acc: U, value: T) -> U, initial: U) -> U) -> U

isSome :: Option f => () -> boolean

Option<T>.isSome() -> boolean

isNone :: Option f => () -> boolean

Option<T>.isNone() -> boolean

Result

Represents a value which may fail.

Methods

of :: Result f => a -> f a

Result.of<a>(value: a) -> Result<a, ()>

zero :: Result f => () -> f a

Result.zero() -> Result<(), ()>

chain :: Result m => m a ~> (a -> m b) -> m b

Result<T, E>.chain<U>(fn: (value: T) -> Result<U, E>) -> Result<U, E>

map :: Result f => f a ~> (a -> b) -> f b

Result<T, E>.map<U>(fn: (value: T) -> U) -> Result<U, E>

alt :: Result f => f a ~> f a -> f a

Result<T, E>.alt(other: Result<T, E>) -> Result<T, E>

fold :: Result f => f a ~> ((b, a) -> b, b) -> b

Result<T, E>.fold<U>(fn: ((acc: U, value: T) -> U, initial: U) -> U) -> U

bimap :: Result f => f a c ~> (a -> b, c -> d) -> f b d

Result<T1, E1>.bimap<T2, E2>(x: (value: T1) -> T2, y: (error: E1) -> E2) -> Result<T2, E2>

isOk :: Result f => () -> boolean

Result<T, E>.isOk() -> boolean

isErr :: Result f => () -> boolean

Result<T, E>.isErr() -> boolean