These

These: object

Defined in: Core/These.ts:26

Type Declaration

chainFirst

chainFirst: <A, B, C>(f) => (data) => These<C, B>

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

Type Parameters

A

A

B

B

C

C

Parameters

f

(a) => These<C, B>

Returns

(data) => These<C, B>

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: <A, B, D>(f) => (data) => These<A, D>

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

Type Parameters

A

A

B

B

D

D

Parameters

f

(b) => These<A, D>

Returns

(data) => These<A, D>

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)

fold

fold: <A, B, C>(onFirst, onSecond, onBoth) => (data) => C

Extracts a value from a These by providing handlers for all three cases.

Type Parameters

A

A

B

B

C

C

Parameters

onFirst

(a) => C

onSecond

(b) => C

onBoth

(a, b) => C

Returns

(data) => C

Example

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

getFirstOrElse

getFirstOrElse: <A, C>(defaultValue) => <B>(data) => A | C

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

A

A

C

C

Parameters

defaultValue

() => C

Returns

<B>(data) => A | C

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: <B, D>(defaultValue) => <A>(data) => B | D

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

B

B

D

D

Parameters

defaultValue

() => D

Returns

<A>(data) => B | D

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>(data) => data is TheseFirst<A> | TheseBoth<A, B>

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

Type Parameters

A

A

B

B

Parameters

data

These<A, B>

Returns

data is TheseFirst<A> | TheseBoth<A, B>

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>(data) => data is TheseSecond<B> | TheseBoth<A, B>

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

Type Parameters

A

A

B

B

Parameters

data

These<A, B>

Returns

data is TheseSecond<B> | TheseBoth<A, B>

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>(data) => data is TheseBoth<A, B> = isBoth

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

Type Parameters

A

A

B

B

Parameters

data

These<A, B>

Returns

data is TheseBoth<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>(data) => data is TheseFirst<A> = isFirst

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

Type Parameters

A

A

B

B

Parameters

data

These<A, B>

Returns

data is TheseFirst<A>

Example

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

is.second

second: <A, B>(data) => data is TheseSecond<B> = isSecond

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

Type Parameters

A

A

B

B

Parameters

data

These<A, B>

Returns

data is TheseSecond<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>(f, s) => TheseBoth<A, B> = makeBoth

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

Type Parameters

A

A

B

B

Parameters

f

A

s

B

Returns

TheseBoth<A, B>

Example

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

make.first

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

Creates a These holding only a first value.

Type Parameters

A

A

Parameters

value

A

Returns

TheseFirst<A>

Example

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

make.second

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

Creates a These holding only a second value.

Type Parameters

B

B

Parameters

value

B

Returns

TheseSecond<B>

Example

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

mapBoth

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

Transforms both the first and second values independently.

Type Parameters

A

A

C

C

B

B

D

D

Parameters

onFirst

(a) => C

onSecond

(b) => D

Returns

(data) => These<C, D>

Example

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

mapFirst

mapFirst: <A, C>(f) => <B>(data) => These<C, B>

Transforms the first value, leaving the second unchanged.

Type Parameters

A

A

C

C

Parameters

f

(a) => C

Returns

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

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>(f) => <A>(data) => These<A, D>

Transforms the second value, leaving the first unchanged.

Type Parameters

B

B

D

D

Parameters

f

(b) => D

Returns

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

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) => (data) => C

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

Type Parameters

A

A

B

B

C

C

Parameters

cases

both

(a, b) => C

first

(a) => C

second

(b) => C

Returns

(data) => C

Example

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

swap

swap: <A, B>(data) => 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

data

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)

tap

tap: <A>(f) => <B>(data) => These<A, B>

Runs a side effect on the first value without changing the These. Useful for logging or debugging.

Type Parameters

A

A

Parameters

f

(a) => void

Returns

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

Example

pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)