FuncType - v1.4.1
    Preparing search index...

    Type Alias LazyType

    LazyType: <T extends unknown>(thunk: () => T) => LazyType<T> & {
        evaluated: <T extends unknown>(value: T) => LazyType<T>;
        fail: <T extends unknown>(error: unknown) => LazyType<T>;
        fromEither: <E, T extends unknown>(either: Either<E, T>) => LazyType<T>;
        fromJSON: <T extends unknown>(json: string) => LazyType<T>;
        fromOption: <T extends unknown>(
            option: Option<T>,
            defaultThunk: () => T,
        ) => LazyType<T>;
        fromPromise: <T extends unknown>(_promise: Promise<T>) => LazyType<T>;
        fromTry: <T extends unknown>(tryValue: Try<T>) => LazyType<T>;
        fromValue: <T extends unknown>(value: T) => LazyType<T>;
        of: <T extends unknown>(thunk: () => T) => LazyType<T>;
    }

    Creates a Lazy computation that defers evaluation until needed. Results are memoized after first evaluation.

    Type Declaration

      • <T extends unknown>(thunk: () => T): LazyType<T>

      • Internal constructor for creating Lazy instances

        Type Parameters

        • T extends unknown

        Parameters

        • thunk: () => T

        Returns LazyType<T>

    • evaluated: <T extends unknown>(value: T) => LazyType<T>

      Creates an already-evaluated Lazy. Used by fromJSON to reconstruct a Lazy whose thunk was forced at serialize time — there is no original thunk to defer because a closure cannot be JSON-serialized.

      Functionally equivalent to Lazy.fromValue but reads with intent at the call site.

    • fail: <T extends unknown>(error: unknown) => LazyType<T>

      Creates a failed Lazy that will throw when evaluated

    • fromEither: <E, T extends unknown>(either: Either<E, T>) => LazyType<T>

      Creates a Lazy from an Either

    • fromJSON: <T extends unknown>(json: string) => LazyType<T>

      Reconstruct a Lazy from a JSON envelope emitted by serialize().toJSON() or instance toJSON(). Verifies @functype === "Lazy". Success envelopes become already-evaluated Lazies via Lazy.evaluated; failure envelopes become Lazies whose forcing rethrows the deserialized Error (see error-envelope.ts — instanceof SomeError does NOT survive but name does).

    • fromOption: <T extends unknown>(option: Option<T>, defaultThunk: () => T) => LazyType<T>

      Creates a Lazy from an Option

    • fromPromise: <T extends unknown>(_promise: Promise<T>) => LazyType<T>

      Creates a Lazy that will throw an error since promises need to be awaited first

    • fromTry: <T extends unknown>(tryValue: Try<T>) => LazyType<T>

      Creates a Lazy from a Try

    • fromValue: <T extends unknown>(value: T) => LazyType<T>

      Creates a Lazy from an immediate value

    • of: <T extends unknown>(thunk: () => T) => LazyType<T>

      Creates a Lazy from a thunk (deferred computation)

    // Basic lazy evaluation
    const expensive = Lazy(() => {
      console.log("Computing...")
      return 42
    })
    // Nothing printed yet
    const result = expensive.orThrow() // Prints "Computing..." and returns 42
    const cached = expensive.orThrow() // Returns 42 without printing

    // Error handling
    const risky = Lazy(() => {
      if (Math.random() > 0.5) throw new Error("Failed")
      return "Success"
    })
    const safe = risky.orElse("Default") // Returns "Success" or "Default"
    const option = risky.toOption() // Some("Success") or None
    const either = risky.toEither() // Right("Success") or Left(Error)

    // Chaining computations
    const result = Lazy(() => 10)
      .map(x => x * 2)
      .flatMap(x => Lazy(() => x + 5))
      .recover(err => 0)
      .orThrow() // 25

    // Integration with functype
    const userOption = Option({ id: 1, name: "Alice" })
    const userName = Lazy.fromOption(userOption, () => ({ id: 0, name: "Anonymous" }))
      .map(user => user.name)
      .orThrow() // "Alice"

    Settings

    Member Visibility