<A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}): (self: Duration) => A | B | C | D
<A, B, C, D = C>(
self: Duration,
options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
): A | B | C | DPattern matches on the representation of a Duration.
Details
Provide handlers for millisecond-backed values, nanosecond-backed values,
and positive infinity. Use onNegativeInfinity to handle negative infinity
separately; otherwise negative infinity is handled by onInfinity.
Example (Pattern matching on duration representations)
import { Duration } from "effect"
const result = Duration.match(Duration.seconds(5), {
onMillis: (millis) => `${millis} milliseconds`,
onNanos: (nanos) => `${nanos} nanoseconds`,
onInfinity: () => "infinite"
})
console.log(result) // "5000 milliseconds"pattern matching
Source effect/Duration.ts:101938 lines
export const const match: {
<A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}): (self: Duration) => A | B | C | D
<A, B, C, D = C>(
self: Duration,
options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
): A | B | C | D
}
Pattern matches on the representation of a Duration.
Details
Provide handlers for millisecond-backed values, nanosecond-backed values,
and positive infinity. Use onNegativeInfinity to handle negative infinity
separately; otherwise negative infinity is handled by onInfinity.
Example (Pattern matching on duration representations)
import { Duration } from "effect"
const result = Duration.match(Duration.seconds(5), {
onMillis: (millis) => `${millis} milliseconds`,
onNanos: (nanos) => `${nanos} nanoseconds`,
onInfinity: () => "infinite"
})
console.log(result) // "5000 milliseconds"
match: {
<function (type parameter) A in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) B in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) C in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) D in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) C in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onMillis: (millis: number) => AonMillis: (millis: numbermillis: number) => function (type parameter) A in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
onNanos: (nanos: bigint) => BonNanos: (nanos: bigintnanos: bigint) => function (type parameter) B in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
onInfinity: () => ConInfinity: () => function (type parameter) C in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
onNegativeInfinity?: (() => D) | undefinedonNegativeInfinity?: () => function (type parameter) D in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
self: Duration(parameter) self: {
value: DurationValue;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
function (type parameter) A in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) B in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) C in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) D in <A, B, C, D = C>(options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): (self: Duration) => A | B | C | D
function (type parameter) A in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) B in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
self: Duration(parameter) self: {
value: DurationValue;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onMillis: (millis: number) => AonMillis: (millis: numbermillis: number) => function (type parameter) A in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
onNanos: (nanos: bigint) => BonNanos: (nanos: bigintnanos: bigint) => function (type parameter) B in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
onInfinity: () => ConInfinity: () => function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
onNegativeInfinity?: (() => D) | undefinedonNegativeInfinity?: () => function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) A in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) B in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
dual<(...args: Array<any>) => any, <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}) => A | B | C | D>(arity: 2, body: <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}) => A | B | C | D): ((...args: Array<any>) => any) & (<A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}) => A | B | C | D) (+1 overload)
Creates a function that can be called in data-first style or data-last
(pipe-friendly) style.
When to use
Use to expose one implementation through both direct and pipe-friendly
call styles.
Details
Pass either the arity of the uncurried function or a predicate that decides
whether the current call is data-first. Arity is the common case. Use a
predicate when optional arguments make arity ambiguous.
Example (Selecting data-first or data-last style by arity)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(2, (self, that) => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Defining overloads with call signatures)
import { Function, pipe } from "effect"
const sum: {
(that: number): (self: number) => number
(self: number, that: number): number
} = Function.dual(2, (self: number, that: number): number => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Selecting data-first or data-last style with a predicate)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(
(args) => args.length === 2,
(self, that) => self + that
)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
dual(2, <function (type parameter) A in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) B in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
self: Duration(parameter) self: {
value: DurationValue;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onMillis: (millis: number) => AonMillis: (millis: numbermillis: number) => function (type parameter) A in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
onNanos: (nanos: bigint) => BonNanos: (nanos: bigintnanos: bigint) => function (type parameter) B in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
onInfinity: () => ConInfinity: () => function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
onNegativeInfinity?: (() => D) | undefinedonNegativeInfinity?: () => function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) A in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) B in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) C in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
self: Duration(parameter) self: {
value: DurationValue;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
Duration.value: DurationValuevalue._tag: | "Millis"
| "Nanos"
| "Infinity"
| "NegativeInfinity"
options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onMillis: (millis: number) => AonMillis(self: Duration(parameter) self: {
value: DurationValue;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
Duration.value: DurationValuevalue.millis: numbermillis)
case "Nanos":
return options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onNanos: (nanos: bigint) => BonNanos(self: Duration(parameter) self: {
value: DurationValue;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
Duration.value: DurationValuevalue.nanos: bigintnanos)
case "Infinity":
return options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onInfinity: () => ConInfinity()
case "NegativeInfinity":
return (options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onNegativeInfinity?: (() => D) | undefinedonNegativeInfinity ?? options: {
readonly onMillis: (millis: number) => A
readonly onNanos: (nanos: bigint) => B
readonly onInfinity: () => C
readonly onNegativeInfinity?: () => D
}
onInfinity: () => ConInfinity as unknown as () => function (type parameter) D in <A, B, C, D = C>(self: Duration, options: {
readonly onMillis: (millis: number) => A;
readonly onNanos: (nanos: bigint) => B;
readonly onInfinity: () => C;
readonly onNegativeInfinity?: () => D;
}): A | B | C | D
Referenced by 9 symbols