Interface LazyType<T>

The Lazy type represents a computation that is deferred until needed. It provides memoization and safe evaluation with integration to Option, Either, and Try.

interface LazyType<out T extends Type> {
 _tag: "Lazy";
 "[toStringTag]": string;
 foldLeft: (z: B) => (op: (b: B, a: T) => B) => B;
 foldRight: (z: B) => (op: (a: T, b: B) => B) => B;
 isEvaluated: boolean;
 get isEmpty(): boolean;
 get size(): number;
 ap(ff: LazyType<(value: T) => U>): LazyType;
 contains(value: unknown): boolean;
 count(p: (x: T) => boolean): number;
 exists(p: (a: T) => boolean): boolean;
 filter(predicate: (value: T) => boolean): LazyType<Option<T>>;
 find(p: (a: T) => boolean): Option<T>;
 flatMap(f: (value: T) => LazyType): LazyType;
 flatMapAsync(
 f: (value: T) => Promise<LazyType>,
 ): Promise<LazyType>;
 fold(f: (value: T) => U): U;
 foldWith(
 onFailure: (error: unknown) => U,
 onSuccess: (value: T) => U,
 ): U;
 forEach(f: (a: T) => void): void;
 map(f: (value: T) => U): LazyType;
 mapAsync(
 f: (value: T) => Promise,
 ): Promise<LazyType>;
 match<R>(patterns: { Lazy: (value: T) => R }): R;
 or<T2 extends unknown>(alternative: LazyType<T2>): LazyType<T | T2>;
 orElse<T2 extends unknown>(defaultValue: T2): T | T2;
 orNull(): T | null;
 orThrow(error?: Error): T;
 orUndefined(): T | undefined;
 pipe(f: (value: T) => U): U;
 recover(f: (error: unknown) => T): LazyType<T>;
 recoverWith(f: (error: unknown) => LazyType<T>): LazyType<T>;
 reduce(
 op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
 ): Widen<T, B>;
 reduceRight(
 op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
 ): Widen<T, B>;
 serialize(): SerializationMethods<T>;
 tap(f: (value: T) => void): LazyType<T>;
 tapError(f: (error: unknown) => void): LazyType<T>;
 toEither(): Either<unknown, T>;
 toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>;
 toJSON(): | { _tag: "Lazy"; "@functype": "Lazy"; value: T }
 | { _tag: "Lazy"; "@functype": "Lazy"; error: SerializedError };
 toOption(): Option<T>;
 toString(): string;
 toTry(): Try<T>;
 toValue(): { _tag: "Lazy"; value: T } | { _tag: "Lazy"; error: Error };
}

Type Parameters

out T extends Type
The type of the value to be computed

Hierarchy (View Summary)

FunctypeBase<T, "Lazy">
Extractable<T>
Pipe<T>
- LazyType

Index

Properties

`Readonly`_tag

_tag: "Lazy"

Tag identifying this as a Lazy type

`Readonly`[toStringTag]

"[toStringTag]": string

foldLeft

foldLeft: (z: B) => (op: (b: B, a: T) => B) => B

Left fold operation

Type Declaration

- (z: B): (op: (b: B, a: T) => B) => B
- Type Parameters
 - B
 Parameters
 - z: B
 Initial value
 Returns (op: (b: B, a: T) => B) => B
 Function that takes an operator and applies it

foldRight

foldRight: (z: B) => (op: (a: T, b: B) => B) => B

Right fold operation

Type Declaration

- (z: B): (op: (a: T, b: B) => B) => B
- Type Parameters
 - B
 Parameters
 - z: B
 Initial value
 Returns (op: (a: T, b: B) => B) => B
 Function that takes an operator and applies it

`Readonly`isEvaluated

isEvaluated: boolean

Whether the computation has been evaluated

Accessors

isEmpty

get isEmpty(): boolean
Returns boolean
Inherited from FunctypeBase.isEmpty

size

get size(): number
Returns number
Inherited from FunctypeBase.size

Methods

ap

ap(ff: LazyType<(value: T) => U>): LazyType
Applies a wrapped function to a wrapped value (Applicative pattern)
Type Parameters
- U extends unknown
Parameters
- ff: LazyType<(value: T) => U>
 A Lazy containing a function from T to U
Returns LazyType
A new Lazy containing the result

Overrides FunctypeBase.ap

contains

contains(value: unknown): boolean
Parameters
- value: unknown
Returns boolean
Inherited from FunctypeBase.contains

count

count(p: (x: T) => boolean): number
Counts elements that satisfy the predicate. For single-value containers: returns 0 or 1 For collections: returns the count of matching elements
Parameters
- p: (x: T) => boolean
Returns number
Inherited from FunctypeBase.count

exists

exists(p: (a: T) => boolean): boolean
Tests whether any element satisfies the predicate. For single-value containers: tests the single value For collections: returns true if any element matches
Parameters
- p: (a: T) => boolean
Returns boolean
Inherited from FunctypeBase.exists

filter

filter(predicate: (value: T) => boolean): LazyType<Option<T>>
Returns a Lazy that filters the value based on a predicate
Parameters
- predicate: (value: T) => boolean
 The predicate function
Returns LazyType<Option<T>>
A Lazy containing an Option of the value

find

find(p: (a: T) => boolean): Option<T>
Finds the first element that satisfies the predicate. For single-value containers: returns Some(value) if predicate matches, None otherwise For collections: returns the first matching element wrapped in Option
Parameters
- p: (a: T) => boolean
Returns Option<T>
Inherited from FunctypeBase.find

flatMap

flatMap(f: (value: T) => LazyType): LazyType
Maps the value using a function that returns a Lazy
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => LazyType
 The mapping function returning a Lazy
Returns LazyType
A new Lazy containing the flattened result

Overrides FunctypeBase.flatMap

flatMapAsync

flatMapAsync(
f: (value: T) => Promise<LazyType>,
): Promise<LazyType>
Maps the value using an async function that returns a Lazy
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => Promise<LazyType>
 The async mapping function returning a Lazy
Returns Promise<LazyType>
A Promise of a new Lazy containing the flattened result

Overrides FunctypeBase.flatMapAsync

fold

fold(f: (value: T) => U): U
Pattern matching on the Lazy value
Type Parameters
- U
Parameters
- f: (value: T) => U
 Function to apply to the computed value
Returns U
The result of applying f to the computed value

foldWith

foldWith(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U
Pattern matching with success and failure handlers
Type Parameters
- U
Parameters
- onFailure: (error: unknown) => U
 Function to handle computation failure
- onSuccess: (value: T) => U
 Function to handle successful computation
Returns U
The result of the appropriate handler

forEach

forEach(f: (a: T) => void): void
Applies an effect function to each element. For single-value containers: applies to the value if present For collections: applies to each element
Parameters
- f: (a: T) => void
Returns void
Inherited from FunctypeBase.forEach

map

map(f: (value: T) => U): LazyType
Maps the value inside the Lazy using the provided function
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => U
 The mapping function
Returns LazyType
A new Lazy containing the mapped value

Overrides FunctypeBase.map

mapAsync

mapAsync(f: (value: T) => Promise): Promise<LazyType>
Maps the value inside the Lazy using an async function
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => Promise
 The async mapping function
Returns Promise<LazyType>
A Promise of a new Lazy containing the mapped value

match

match<R>(patterns: { Lazy: (value: T) => R }): R
Pattern matching for the Lazy type
Type Parameters
- R
Parameters
- patterns: { Lazy: (value: T) => R }
 Object with handler for Lazy pattern
Returns R
The result of the matched handler

or

or<T2 extends unknown>(alternative: LazyType<T2>): LazyType<T | T2>
Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy. The alternative may carry a different type; result is Lazy<T | T2>.
Type Parameters
- T2 extends unknown
Parameters
- alternative: LazyType<T2>
Returns LazyType<T | T2>
Overrides Extractable.or

orElse

orElse<T2 extends unknown>(defaultValue: T2): T | T2
Returns the computed value or a default value if computation fails. Result widens to T | T2 (Scala: getOrElse[B >: A](default: B): B).
Type Parameters
- T2 extends unknown
Parameters
- defaultValue: T2
Returns T | T2
Overrides Extractable.orElse

orNull

orNull(): T | null
Returns the computed value or null if computation fails

Returns T | null
The computed value or null

Overrides Extractable.orNull

orThrow

orThrow(error?: Error): T
Returns the computed value or throws an error if computation fails
Parameters
- Optionalerror: Error
  Optional custom error to throw. If not provided, throws the computation error or a default error
Returns T
The computed value

Throws
The specified error, computation error, or a default error

Overrides Extractable.orThrow

orUndefined

orUndefined(): T | undefined
Returns the contained value or undefined

Returns T | undefined
The contained value or undefined

Inherited from Extractable.orUndefined

pipe

pipe(f: (value: T) => U): U
Pipes the value through the provided function
Type Parameters
- U extends unknown
 The return type of the function
Parameters
- f: (value: T) => U
 The function to apply to the value
Returns U
The result of applying the function to the value

Inherited from Pipe.pipe

recover

recover(f: (error: unknown) => T): LazyType<T>
Recovers from a failed computation by providing an alternative value
Parameters
- f: (error: unknown) => T
 Function that takes the error and returns a recovery value
Returns LazyType<T>
A new Lazy that will use the recovery function if computation fails

recoverWith

recoverWith(f: (error: unknown) => LazyType<T>): LazyType<T>
Recovers from a failed computation by providing an alternative Lazy
Parameters
- f: (error: unknown) => LazyType<T>
 Function that takes the error and returns a recovery Lazy
Returns LazyType<T>
A new Lazy that will use the recovery Lazy if computation fails

reduce

reduce(op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>): Widen<T, B>
Type Parameters
- B = T
Parameters
- op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>
Returns Widen<T, B>
Inherited from FunctypeBase.reduce

reduceRight

reduceRight(
op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
): Widen<T, B>
Type Parameters
- B = T
Parameters
- op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>
Returns Widen<T, B>
Inherited from FunctypeBase.reduceRight

serialize

serialize(): SerializationMethods<T>
Returns SerializationMethods<T>
Inherited from FunctypeBase.serialize

tap

tap(f: (value: T) => void): LazyType<T>
Applies an effect function to the value if computation succeeds
Parameters
- f: (value: T) => void
 The effect function
Returns LazyType<T>
This Lazy for chaining

tapError

tapError(f: (error: unknown) => void): LazyType<T>
Applies an effect function to the error if computation fails
Parameters
- f: (error: unknown) => void
 The effect function for errors
Returns LazyType<T>
This Lazy for chaining

toEither

toEither(): Either<unknown, T>
Evaluates the computation and returns it as an Either

Returns Either<unknown, T>
Right containing the value if successful, Left containing the error if computation fails

toEitherWith

toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>
Evaluates the computation and returns it as an Either with a mapped error
Type Parameters
- E
Parameters
- mapError: (error: unknown) => E
 Function to map the error
Returns Either<E, T>
Right containing the value if successful, Left containing the mapped error if computation fails

toJSON

toJSON(): | { _tag: "Lazy"; "@functype": "Lazy"; value: T }
| { _tag: "Lazy"; "@functype": "Lazy"; error: SerializedError }
Custom JSON serialization. Forces the thunk (see toValue for the side-effect contract). Emits {"@functype":"Lazy","_tag":"Lazy","value":T} on success, or {"@functype":"Lazy","_tag":"Lazy","error":SerializedError} if the thunk threw — see error-envelope.ts for round-trip semantics.

Returns
| { _tag: "Lazy"; "@functype": "Lazy"; value: T }
| { _tag: "Lazy"; "@functype": "Lazy"; error: SerializedError }
Overrides FunctypeBase.toJSON

toOption

toOption(): Option<T>
Evaluates the computation and returns it as an Option

Returns Option<T>
Some containing the value if successful, None if computation fails

toString

toString(): string
Creates a string representation of the Lazy

Returns string
String representation showing evaluation status

toTry

toTry(): Try<T>
Evaluates the computation and returns it as a Try

Returns Try<T>
Try containing the result of the computation

toValue

toValue(): { _tag: "Lazy"; value: T } | { _tag: "Lazy"; error: Error }
Converts the Lazy to a value object.

Forces the thunk as a side effect — Lazy serialization (and projection to a plain value object) cannot represent an unevaluated thunk in JSON; forcing is the only way to produce a complete projection. If the thunk threw, the failure is captured in the error field (real Error, with full prototype intact for in-memory inspection — toJSON projects to SerializedError for the wire).

Changed in 1.2.0 — pre-1.2.0 Lazy emitted {_tag, evaluated, value?} without forcing. See docs/archive/proposals/serializable-audit-q1-q2.md.

Returns { _tag: "Lazy"; value: T } | { _tag: "Lazy"; error: Error }

Interface LazyType<T>

Type Parameters

Hierarchy (View Summary)

Index

Properties

Accessors

Methods

Properties

Readonly_tag

Readonly[toStringTag]

foldLeft

Type Declaration

Type Parameters

Parameters

Returns (op: (b: B, a: T) => B) => B

foldRight

Type Declaration

Type Parameters

Parameters

Returns (op: (a: T, b: B) => B) => B

ReadonlyisEvaluated

Accessors

isEmpty

Returns boolean

size

Returns number

Methods

ap

Type Parameters

Parameters

Returns LazyType<U>

contains

Parameters

Returns boolean

count

Parameters

Returns number

exists

Parameters

Returns boolean

filter

Parameters

Returns LazyType<Option<T>>

find

Parameters

Returns Option<T>

flatMap

Type Parameters

Parameters

Returns LazyType<U>

flatMapAsync

Type Parameters

Parameters

Returns Promise<LazyType<U>>

fold

Type Parameters

Parameters

Returns U

foldWith

Type Parameters

Parameters

Returns U

forEach

Parameters

Returns void

map

Type Parameters

Parameters

Returns LazyType<U>

mapAsync

Type Parameters

Parameters

Returns Promise<LazyType<U>>

match

Type Parameters

Parameters

Returns R

or

Type Parameters

Parameters

`Readonly`_tag

`Readonly`[toStringTag]

`Readonly`isEvaluated

Returns
| { _tag: "Lazy"; "@functype": "Lazy"; value: T }
| { _tag: "Lazy"; "@functype": "Lazy"; error: SerializedError }