These

These: object

Defined in: Core/These.ts:28

Type Declaration

chainFirst

chainFirst: <A, C, B2>(transform) => <B1>(these) => These<C, B2 | B1>

Chains These computations by passing the first value to transform. Second propagates unchanged; First and Both apply transform to the first value.

Type Parameters

A

A

C

C

B2

B2 = never

Parameters

transform

(first) => These<C, B2>

Returns

<B1>(these) => These<C, B2 | B1>

See

These.chainSecond to chain based on the second value.

Example

const double = (n: number): These<number, string> => These.make.first(n * 2);

pipe(These.make.first(5), These.chainFirst(double));            // First(10)
pipe(These.make.both(5, "warn"), These.chainFirst(double));     // First(10)
pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")

chainSecond

chainSecond: <B, D, A2>(transform) => <A1>(these) => These<A2 | A1, D>

Chains These computations by passing the second value to transform. First propagates unchanged; Second and Both apply transform to the second value.

Type Parameters

B

B

D

D

A2

A2 = never

Parameters

transform

(second) => These<A2, D>

Returns

<A1>(these) => These<A2 | A1, D>

See

These.chainFirst to chain based on the first value.

Example

const shout = (s: string): These<number, string> => These.make.second(s.toUpperCase());

pipe(These.make.second("warn"), These.chainSecond(shout));      // Second("WARN")
pipe(These.make.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
pipe(These.make.first(5), These.chainSecond(shout));            // First(5)

from

from: object

from.Pair

Pair: <A, B>(pair) => Both<A, B>

Creates a These.Both holding both values of a Pair.

Type Parameters

A

A

B

B

Parameters

pair

Pair<A, B>

Returns

Both<A, B>

See

These.to.Pair to extract a Pair from a These when both values are present.

Example

These.from.Pair(Pair.make("Paris", 2_161_000)); // Both("Paris", 2161000)

getFirstOrElse

getFirstOrElse: <C>(fallback) => <A, B>(these) => C | A

Returns the first value, or a default if the These has no first value. The default can be a different type, widening the result to A | C.

Type Parameters

C

C

Parameters

fallback

() => C

Returns

<A, B>(these) => C | A

See

These.getSecondOrElse to retrieve the second value with fallback.

Example

pipe(These.make.first(5), These.getFirstOrElse(() => 0));            // 5
pipe(These.make.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
pipe(These.make.second("warn"), These.getFirstOrElse(() => 0));      // 0
pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null

getSecondOrElse

getSecondOrElse: <D>(fallback) => <B, A>(these) => D | B

Returns the second value, or a default if the These has no second value. The default can be a different type, widening the result to B | D.

Type Parameters

D

D

Parameters

fallback

() => D

Returns

<B, A>(these) => D | B

See

These.getFirstOrElse to retrieve the first value with fallback.

Example

pipe(These.make.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
pipe(These.make.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
pipe(These.make.first(5), These.getSecondOrElse(() => "none"));       // "none"
pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null

hasFirst

hasFirst: <A, B>(these) => these is First<A> | Both<A, B>

Returns true if the These contains a first value (First or Both).

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

these is First<A> | Both<A, B>

See

These.hasSecond to check if These contains a second value.

Example

These.hasFirst(These.make.first(42));       // true
These.hasFirst(These.make.both(42, "warn"));// true
These.hasFirst(These.make.second("warn"));  // false

hasSecond

hasSecond: <A, B>(these) => these is Second<B> | Both<A, B>

Returns true if the These contains a second value (Second or Both).

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

these is Second<B> | Both<A, B>

See

These.hasFirst to check if These contains a first value.

Example

These.hasSecond(These.make.second("warn"));  // true
These.hasSecond(These.make.both(42, "warn"));// true
These.hasSecond(These.make.first(42));       // false

is

is: object

is.both

both: <A, B>(these) => these is Both<A, B> = isBoth

Type guard — checks if a These holds both values simultaneously.

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

these is Both<A, B>

Example

const val = These.make.both(42, "warning");
if (These.is.both(val)) {
  console.log(val.first, val.second); // 42 "warning"
}

is.first

first: <A, B>(these) => these is First<A> = isFirst

Type guard — checks if a These holds only a first value.

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

these is First<A>

Example

const val = These.make.first(42);
if (These.is.first(val)) {
  console.log(val.first); // 42
}

is.second

second: <A, B>(these) => these is Second<B> = isSecond

Type guard — checks if a These holds only a second value.

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

these is Second<B>

Example

const val = These.make.second("warning");
if (These.is.second(val)) {
  console.log(val.second); // "warning"
}

make

make: object

make.both

both: <A, B>(first, second) => Both<A, B> = makeBoth

Creates a These holding both a first and a second value simultaneously.

Type Parameters

A

A

B

B

Parameters

first

A

second

B

Returns

Both<A, B>

Example

These.make.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }

make.first

first: <A>(value) => First<A> = makeFirst

Creates a These holding only a first value.

Type Parameters

A

A

Parameters

value

A

Returns

First<A>

Example

These.make.first(42); // { kind: "First", first: 42 }

make.second

second: <B>(value) => Second<B> = makeSecond

Creates a These holding only a second value.

Type Parameters

B

B

Parameters

value

B

Returns

Second<B>

Example

These.make.second("warning"); // { kind: "Second", second: "warning" }

mapBoth

mapBoth: <A, C, B, D>(onFirst, onSecond) => (these) => These<C, D>

Transforms both the first and second values independently.

Type Parameters

A

A

C

C

B

B

D

D

Parameters

onFirst

(first) => C

onSecond

(second) => D

Returns

(these) => These<C, D>

See

• These.mapFirst to transform only the first element.
• These.mapSecond to transform only the second element.

Example

pipe(
  These.make.both(5, "warn"),
  These.mapBoth(n => n * 2, e => e.toUpperCase())
); // Both(10, "WARN")

mapFirst

mapFirst: <A, C>(transform) => <B>(these) => These<C, B>

Transforms the first value, leaving the second unchanged.

Type Parameters

A

A

C

C

Parameters

transform

(first) => C

Returns

<B>(these) => These<C, B>

See

• These.mapSecond to transform the second element.
• These.mapBoth to transform both elements.

Example

pipe(These.make.first(5), These.mapFirst(n => n * 2));           // First(10)
pipe(These.make.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")

mapSecond

mapSecond: <B, D>(transform) => <A>(these) => These<A, D>

Transforms the second value, leaving the first unchanged.

Type Parameters

B

B

D

D

Parameters

transform

(second) => D

Returns

<A>(these) => These<A, D>

See

• These.mapFirst to transform the first element.
• These.mapBoth to transform both elements.

Example

pipe(These.make.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
pipe(These.make.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")

match

match: <A, B, C>(cases) => (these) => C

Pattern matches on a These, returning the result of the matching case.

Type Parameters

A

A

B

B

C

C

Parameters

cases

both

(first, second) => C

first

(first) => C

second

(second) => C

Returns

(these) => C

Example

pipe(
  these,
  These.match({
    first: a => `First: ${a}`,
    second: b => `Second: ${b}`,
    both: (a, b) => `Both: ${a} / ${b}`
  })
);

swap

swap: <A, B>(these) => These<B, A>

Swaps the roles of first and second values.

• First(a) → Second(a)
• Second(b) → First(b)
• Both(a, b) → Both(b, a)

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

These<B, A>

Example

These.swap(These.make.first(5));            // Second(5)
These.swap(These.make.second("warn"));      // First("warn")
These.swap(These.make.both(5, "warn"));     // Both("warn", 5)

tapBoth

tapBoth: <A, B>(sideEffect) => (these) => These<A, B>

Runs a side effect on both values when both are present simultaneously (Both variant only).

Type Parameters

A

A

B

B

Parameters

sideEffect

(first, second) => void

Returns

(these) => These<A, B>

See

• These.tapFirst to run a side effect on the first value.
• These.tapSecond to run a side effect on the second value.

Example

pipe(
  These.make.both(5, "warn"),
  These.tapBoth((n, w) => console.log(`${n} with warning ${w}`)),
); // logs "5 with warning warn"

tapFirst

tapFirst: <A>(sideEffect) => <B>(these) => These<A, B>

Runs a side effect on the first value (if present in First or Both) without changing the These. Useful for logging or debugging.

Type Parameters

A

A

Parameters

sideEffect

(first) => void

Returns

<B>(these) => These<A, B>

See

• These.tapSecond to run a side effect on the second value instead.
• These.tapBoth to run a side effect on both values when both are present.

Example

pipe(These.make.first(5), These.tapFirst(console.log)); // logs 5, returns First(5)
pipe(These.make.both(5, "warn"), These.tapFirst(console.log)); // logs 5, returns Both(5, "warn")

tapSecond

tapSecond: <B>(sideEffect) => <A>(these) => These<A, B>

Runs a side effect on the second value (if present in Second or Both) without changing the These. Useful for logging or reporting warnings.

Type Parameters

B

B

Parameters

sideEffect

(second) => void

Returns

<A>(these) => These<A, B>

See

• These.tapFirst to run a side effect on the first value instead.
• These.tapBoth to run a side effect on both values when both are present.

Example

pipe(These.make.second("warn"), These.tapSecond(console.warn)); // logs "warn", returns Second("warn")
pipe(These.make.both(5, "warn"), These.tapSecond(console.warn)); // logs "warn", returns Both(5, "warn")

to

to: object

to.Pair

Pair: <A, B>(these) => Maybe<Pair<A, B>>

Converts a These to a Maybe containing a Pair if both values are present. Returns Some([first, second]) for Both; returns None for First and Second.

Type Parameters

A

A

B

B

Parameters

these

These<A, B>

Returns

Maybe<Pair<A, B>>

See

These.from.Pair to create a These.Both from a Pair.

Example

These.to.Pair(These.make.both("Paris", 2_161_000)); // Some(["Paris", 2161000])
These.to.Pair(These.make.first("Paris"));           // None
These.to.Pair(These.make.second(2_161_000));        // None