dechainer

Dechainer

Dechainer is a Node.js library written in TypeScript containing versatile utilities designed to aid development in the functional programming paradigm.

Installation

npm i dechainer

Imports

Contrived examples demonstrating how to import functions and types from this library.

JavaScript

import { identity } from 'dechainer'

const example = identity('a string')
// example === 'a string'

TypeScript

import type { IdentityCallback } from 'dechainer'
import { identity } from 'dechainer'

const stringIdentity: IdentityCallback<string> = (param: string): string =>
    identity(param),
  example: string = stringIdentity('a string')
// example === 'a string'

Interface

Partial documentation of functions available in this library.

async

delay

Delay code execution by a specified duration.

• delayable is a callback function with an optional duration parameter (e.g.: (duration) => console.log(duration)).
• duration is the time in milliseconds that should elapse before delayable is called.

Unary

await delay({ delayable, duration })

Binary

Parameters can be provided in any order.

await delay(delayable, duration)
// or
await delay(duration, delayable)

Curried

Parameters can be provided in any order.

await delay(delayable)(duration)
// or
await delay(duration)(delayable)

race

Race asynchronous code execution against a specified timeout.

• contender is an asynchronous function that resolves only if the elapsed time is less than the timeout duration.
• timeout is the time in milliseconds that should elapse before a RangeError is thrown.

Unary

await race({ contender, timeout })

Binary

Parameters can be provided in any order.

await race(contender, timeout)
// or
await race(timeout, contender)

Curried

Parameters can be provided in any order.

await race(contender)(timeout)
// or
await race(timeout)(contender)

counter

Counter with optional (im-)persistent internal state and respective tradeoffs. Multiple unique counters of both types may exist without overlapping state.

Persistent

Persistent counter that is purely functional and side effect free with a smaller, simpler interface. Resetting is achieved by declaring a new variable. Return value(s) should be stored to be practical.

const { decrement, increment, state } = counter({ impersistent: false })
// state === 0
// increment().state === 1

Methods

Methods returned by calling counter({ impersistent: false }), each returning a new persistent counter:

• decrement decreases the current value by 1.
• increment increases the current value by 1.

Properties

Properties returned by calling counter({ impersistent: false }):

• state is a number representing the counter's current value.

Impersistent

Impersistent counter that provides many methods that mutate its internal state. However, it only needs to be declared once. State is unique to each counter and not shared globally.

const { count, decrement, increment, reset } = counter({ impersistent: true })
// count() === 0
// increment()
// count() === 1

Methods

Methods returned by calling counter({ impersistent: true }):

• count returns the counter's current number value.
• decrement is a side effect that decreases the internal value by 1.
• increment is a side effect that increases the internal value by 1.
• reset is a side effect that sets the internal value to 0.