Combinable

Combinable: object

Defined in: Core/Combinable.ts:14

Type Declaration

all

all: Combinable<boolean> = allCombinable

Combines booleans with logical AND. true is the neutral element.

Example

pipe([true, true, false], Combinable.fold(Combinable.all)); // false

any

any: Combinable<boolean> = anyCombinable

Combines booleans with logical OR. false is the neutral element.

Example

pipe([false, false, true], Combinable.fold(Combinable.any)); // true

array

array: <A>() => Combinable<readonly A[]>

Combines arrays by concatenation. Empty array is the neutral element.

Type Parameters

A

A

Returns

Combinable<readonly A[]>

Example

pipe([[1, 2], [3], [4, 5]], Combinable.fold(Combinable.array<number>())); // [1, 2, 3, 4, 5]

fold

fold: <A>(c) => (data) => A

Folds an array into a single value using the Combinable’s empty as the starting point.

Type Parameters

A

A

Parameters

c

Combinable<A>

Returns

(data) => A

Example

pipe([1, 2, 3, 4, 5], Combinable.fold(Combinable.sum)); // 15
pipe([], Combinable.fold(Combinable.sum));               // 0

maybe

maybe: <A>(inner) => Combinable<Maybe<A>>

Lifts a Combinable<A> to Combinable<Maybe<A>>. None is the neutral element — combining with None on either side returns the other value unchanged. Two Some values combine their inner values using the inner Combinable.

Type Parameters

A

A

Parameters

inner

Combinable<A>

Returns

Combinable<Maybe<A>>

Example

const c = Combinable.maybe(Combinable.sum);
c.combine(Maybe.make.some(3))(Maybe.make.some(2)); // Some(5)
c.combine(Maybe.make.none())(Maybe.make.some(5));  // Some(5)

product

product: Combinable<number> = productCombinable

Combines numbers by multiplication. 1 is the neutral element.

Example

pipe([2, 3, 4], Combinable.fold(Combinable.product)); // 24

string

string: Combinable<string> = stringCombinable

Combines strings by concatenation. Empty string is the neutral element.

Example

pipe(["a", "b", "c"], Combinable.fold(Combinable.string)); // "abc"

struct

struct: <R>(fields) => Combinable<R>

Derives a Combinable for a record of fields from field-level Combinable instances.

Type Parameters

R

R extends Record<string, unknown>

Parameters

fields

{ [K in string | number | symbol]: Combinable<R[K]> }

Returns

Combinable<R>

Example

const StatsCombinable = Combinable.struct({
  count: Combinable.sum,
  tags: Combinable.array<string>(),
});

sum

sum: Combinable<number> = sumCombinable

Combines numbers by addition. 0 is the neutral element.

Example

pipe([1, 2, 3], Combinable.fold(Combinable.sum)); // 6