Pair

Pair: object

Defined in: Core/Pair.ts:23

Type Declaration

first

first: <A, B>(p) => A

Returns the first value from the pair.

Type Parameters

A

A

B

B

Parameters

p

Pair<A, B>

Returns

A

Example

Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"

fold

fold: <A, B, C>(f) => (p) => C

Applies a binary function to both values, collapsing the pair into a single value. Useful as the final step when consuming a pair in a pipeline.

Type Parameters

A

A

B

B

C

C

Parameters

f

(a, b) => C

Returns

(p) => C

Example

pipe(Pair.from.pair("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
// "Alice: 100"

from

from: object

from.array

array: <A, B>(arr) => Pair<A, B> = makeArray

Creates a Pair from a two-element array.

Type Parameters

A

A

B

B

Parameters

arr

readonly [A, B]

Returns

Pair<A, B>

Example

Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]

from.pair

pair: <A, B>(first, second) => Pair<A, B> = makePair

Creates a Pair from two values.

Type Parameters

A

A

B

B

Parameters

first

A

second

B

Returns

Pair<A, B>

Example

Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]

mapBoth

mapBoth: <A, C, B, D>(onFirst, onSecond) => (p) => Pair<C, D>

Transforms both values independently in a single step.

Type Parameters

A

A

C

C

B

B

D

D

Parameters

onFirst

(a) => C

onSecond

(b) => D

Returns

(p) => Pair<C, D>

Example

pipe(
  Pair.from.pair("alice", 42),
  Pair.mapBoth(
    (name) => name.toUpperCase(),
    (score) => score * 2,
  ),
); // ["ALICE", 84]

mapFirst

mapFirst: <A, C>(f) => <B>(p) => Pair<C, B>

Transforms the first value, leaving the second unchanged.

Type Parameters

A

A

C

C

Parameters

f

(a) => C

Returns

<B>(p) => Pair<C, B>

Example

pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]

mapSecond

mapSecond: <B, D>(f) => <A>(p) => Pair<A, D>

Transforms the second value, leaving the first unchanged.

Type Parameters

B

B

D

D

Parameters

f

(b) => D

Returns

<A>(p) => Pair<A, D>

Example

pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]

second

second: <A, B>(p) => B

Returns the second value from the pair.

Type Parameters

A

A

B

B

Parameters

p

Pair<A, B>

Returns

B

Example

Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000

swap

swap: <A, B>(p) => Pair<B, A>

Swaps the two values: [A, B] becomes [B, A].

Type Parameters

A

A

B

B

Parameters

p

Pair<A, B>

Returns

Pair<B, A>

Example

Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]

tap

tap: <A, B>(f) => (p) => Pair<A, B>

Runs a side effect with both values without changing the pair. Useful for logging or debugging in the middle of a pipeline.

Type Parameters

A

A

B

B

Parameters

f

(a, b) => void

Returns

(p) => Pair<A, B>

Example

pipe(
  Pair.from.pair("Paris", 2_161_000),
  Pair.tap((city, pop) => console.log(`${city}: ${pop}`)),
  Pair.mapSecond((n) => n / 1_000_000),
); // logs "Paris: 2161000", returns ["Paris", 2.161]

to

to: object

to.Array

Array: <A, B>(p) => readonly (A | B)[]

Converts the pair to a heterogeneous readonly array readonly (A | B)[].

Type Parameters

A

A

B

B

Parameters

p

Pair<A, B>

Returns

readonly (A | B)[]

Example

Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]