Uniq

const Uniq: object

Defined in: Data/Uniq.ts:368

Type Declaration

difference

difference: <A>(other) => (set) => ReadonlySet<A>

Computes the set difference (set \ other).

Type Parameters

A

A

Parameters

other

ReadonlySet<A>

Returns

(set) => ReadonlySet<A>

See

• union for combining all elements.
• intersection for keeping only common elements.

empty

empty: <A>() => ReadonlySet<A>

Creates an empty unique set.

Type Parameters

A

A

Returns

ReadonlySet<A>

See

singleton to create a set with one element.

Example

const set = Uniq.empty<number>(); // Set(0) {}

filter

filter: <A>(predicate) => (set) => ReadonlySet<A>

Filters elements of a set by a predicate.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(set) => ReadonlySet<A>

See

filterMap for filtering and mapping simultaneously.

filterMap

filterMap: <A, B>(transform) => (set) => ReadonlySet<B>

Transforms elements with a function returning Maybe, keeping only Some values.

Type Parameters

A

A

B

B

Parameters

transform

(item) => Maybe<B>

Returns

(set) => ReadonlySet<B>

See

• filter for filtering with a boolean predicate.
• map for transforming without filtering.

from

from: object

from.array

array: <A>(items) => ReadonlySet<A> = fromArray

Creates a unique set from an array of elements.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

ReadonlySet<A>

Example

Uniq.from.array([1, 2, 2, 3]); // Set(3) { 1, 2, 3 }

has

has: <A>(item) => (set) => boolean

Returns true when the set contains the given element.

Type Parameters

A

A

Parameters

item

A

Returns

(set) => boolean

See

• insert for inserting an element into a set.
• remove for deleting an element from a set.

insert

insert: <A>(item) => (set) => ReadonlySet<A>

Returns a new set with the element added.

Type Parameters

A

A

Parameters

item

A

Returns

(set) => ReadonlySet<A>

See

• remove for deleting an element from a set.
• toggle for toggling presence of an element.

intersection

intersection: <A>(other) => (set) => ReadonlySet<A>

Computes the intersection of two sets.

Type Parameters

A

A

Parameters

other

ReadonlySet<A>

Returns

(set) => ReadonlySet<A>

See

• union for combining elements from both sets.
• difference for subtracting elements.

is

is: object

is.empty

empty: <A>(set) => boolean = isEmpty

Returns true when the set contains zero elements.

Type Parameters

A

A

Parameters

set

ReadonlySet<A>

Returns

boolean

See

isNonEmpty to check if a set has elements.

Example

Uniq.is.empty(Uniq.empty()); // true
Uniq.is.empty(Uniq.singleton(1)); // false

is.nonEmpty

nonEmpty: <A>(set) => set is NonEmptySet<A> = isNonEmpty

Type guard — checks if a set contains at least one element.

Type Parameters

A

A

Parameters

set

ReadonlySet<A>

Returns

set is NonEmptySet<A>

See

isEmpty to check if a set is empty.

Example

Uniq.is.nonEmpty(Uniq.singleton(1)); // true
Uniq.is.nonEmpty(Uniq.empty());      // false

is.subsetOf

subsetOf: <A>(other) => (set) => boolean = isSubsetOf

Returns true if set is a subset of other.

Type Parameters

A

A

Parameters

other

ReadonlySet<A>

Returns

(set) => boolean

Example

pipe(Uniq.from.array([1, 2]), Uniq.is.subsetOf(Uniq.from.array([1, 2, 3]))); // true

map

map: <A, B>(transform) => (set) => ReadonlySet<B>

Transforms each element of a set into a new set.

Type Parameters

A

A

B

B

Parameters

transform

(item) => B

Returns

(set) => ReadonlySet<B>

See

filterMap for mapping and filtering in a single step.

NonEmpty

NonEmpty: object = UniqNonEmptyConst

Utilities for working with guaranteed non-empty sets (NonEmptySet).

NonEmpty.from

from: object

NonEmpty.from.set

set: <A>(set) => Maybe<NonEmptySet<A>>

Refines a standard Set to a NonEmptySet, returning Some if size > 0, None otherwise.

Type Parameters

A

A

Parameters

set

ReadonlySet<A>

Returns

Maybe<NonEmptySet<A>>

Example

Uniq.NonEmpty.from.set(new Set([1, 2])); // Some(NonEmptySet)
Uniq.NonEmpty.from.set(new Set());        // None

NonEmpty.map

map: <A, B>(transform) => (set) => NonEmptySet<B>

Transforms each element of a non-empty set, preserving non-emptiness.

Type Parameters

A

A

B

B

Parameters

transform

(item) => B

Returns

(set) => NonEmptySet<B>

Example

pipe(Uniq.NonEmpty.singleton(5), Uniq.NonEmpty.map(n => n * 2)); // NonEmptySet { 10 }

NonEmpty.reduce

reduce: <A>(reducer) => (set) => A

Reduces a non-empty set using the first element as the initial accumulator.

Type Parameters

A

A

Parameters

reducer

(accumulator, item) => A

Returns

(set) => A

Example

pipe(Uniq.NonEmpty.singleton(5), Uniq.NonEmpty.reduce((a, b) => a + b)); // 5

NonEmpty.singleton

singleton: <A>(item) => NonEmptySet<A>

Creates a NonEmptySet containing a single element.

Type Parameters

A

A

Parameters

item

A

Returns

NonEmptySet<A>

Example

Uniq.NonEmpty.singleton(42); // NonEmptySet(1) { 42 }

NonEmpty.to

to: object

NonEmpty.to.array

array: <A>(set) => NonEmptyArr<A>

Converts a NonEmptySet to a NonEmptyArr.

Type Parameters

A

A

Parameters

set

NonEmptySet<A>

Returns

NonEmptyArr<A>

Example

Uniq.NonEmpty.to.array(Uniq.NonEmpty.singleton(42)); // [42]

reduce

reduce: <A, B>(initial, reducer) => (set) => B

Reduces elements of a set from an initial value.

Type Parameters

A

A

B

B

Parameters

initial

B

reducer

(accumulator, item) => B

Returns

(set) => B

Example

pipe(Uniq.from.array([1, 2, 3]), Uniq.reduce(0, (acc, n) => acc + n)); // 6

remove

remove: <A>(item) => (set) => ReadonlySet<A>

Returns a new set with the element removed.

Type Parameters

A

A

Parameters

item

A

Returns

(set) => ReadonlySet<A>

See

insert for adding an element to a set.

singleton

singleton: <A>(item) => ReadonlySet<A>

Creates a unique set with a single element.

Type Parameters

A

A

Parameters

item

A

Returns

ReadonlySet<A>

See

empty to create an empty set.

Example

Uniq.singleton(42); // Set(1) { 42 }

size

size: <A>(set) => number

Returns the number of elements in the set.

Type Parameters

A

A

Parameters

set

ReadonlySet<A>

Returns

number

Example

Uniq.size(Uniq.from.array([1, 2, 3])); // 3

to

to: object

Converters from unique collections to other data structures.

to.array

array: <A>(set) => readonly A[] = toArray

Converts a unique set to a readonly array.

Type Parameters

A

A

Parameters

set

ReadonlySet<A>

Returns

readonly A[]

Example

Uniq.to.array(Uniq.from.array([1, 2, 3])); // [1, 2, 3]

toggle

toggle: <A>(item) => (set) => ReadonlySet<A>

Toggles presence of an element in a set.

Type Parameters

A

A

Parameters

item

A

Returns

(set) => ReadonlySet<A>

See

• insert for unconditionally adding an element.
• remove for unconditionally removing an element.

union

union: <A>(other) => (set) => ReadonlySet<A>

Computes the union of two sets.

Type Parameters

A

A

Parameters

other

ReadonlySet<A>

Returns

(set) => ReadonlySet<A>

See

• intersection for keeping only elements present in both sets.
• difference for subtracting elements.