Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

Appearance settings

tungv/brn

Open more actions menu

Repository files navigation

Strongly Typed Functional Branching

brn exports only one function that takes a test, a left, and a right function and return a combined one that will run left if test returns truthy and right otherwise

Example

const brn = require('brn');

const isOdd = x => x % 2;

const left = x => `${x} is odd`;
const right = x => `${x} is even`;

const fn = brn(isOdd, left, right);

console.log(fn(2)); // returns 2 is even
console.log(fn(1)); // returns 1 is odd

TypeScript

import brn from 'brn'

const isOdd = (x: number) => x % 2;

const fn = brn(
  isOdd,
  x => `${x} is odd` as const,
  x => `${x} is even` as const
);

expect(fn(2, 'two')).toBe('2 is even'); // returns 2 is even
expect(fn(1, 'one')).toBe('1 is odd'); // returns 1 is odd

In this example, parameter x in the "left" and "right" functions is typed as number. fn also has return type of `${number} is even` | `${number} is odd`

// another example
function always<X extends string>(x: X) {
  return () => x;
}
const fn = brn(
  (x: number) => x >= 10,
  always(`double digit`),
  brn(
    x => x < 0,
    always('negative'),
    always('single digit')
  )
)

In this example, return type of fn is one of "single digit", "double digit" or "negative".

Releases

Packages

Used by

Contributors

Languages

Morty Proxy This is a proxified and sanitized view of the page, visit original site.