Type Alias SyncEffect<T, E>

Type declaration

• flatMap:function

  • flatMap<U, F>(fn): SyncEffect<U, E | F>

  • Chains another effect-producing function, allowing error propagation.

    Type Parameters

    • U

      The type of the next computation's success value.
    • F

      The type of the new error that may occur.

    Parameters

    • fn: ((value: T) => SyncEffect<U, F>)

      Function returning a new SyncEffect<U, F>.

      • • (value): SyncEffect<U, F>

        • Parameters

          • value: T

          Returns SyncEffect<U, F>

    Returns SyncEffect<U, E | F>

    • A new SyncEffect<U, E | F> propagating errors.

    Example

    const effect = SyncEffect(() => 10).flatMap(x => SyncEffect(() => x + 5));
    console.log(effect.run()); // Ok(15)
    Copy

• map:function

  • map<U>(fn): SyncEffect<U, E>

  • Transforms the successful result of the effect.

    Type Parameters

    • U

      The transformed value type.

    Parameters

    • fn: ((value: T) => U)

      Function to apply on success.

      • • (value): U

        • Parameters

          • value: T

          Returns U

    Returns SyncEffect<U, E>

    • A new SyncEffect<U, E> with transformed data.

    Example

    const effect = SyncEffect(() => 10).map(x => x * 2);
    console.log(effect.run()); // Ok(20)
    Copy

• recover:function

  • recover<U>(fn): SyncEffect<T | U, never>

  • Recovers from errors by mapping them to a successful value.

    Useful for handling failures gracefully.

    Type Parameters

    • U

    Parameters

    • fn: ((error: E) => U)

      Function to handle errors and return a fallback value.

      • • (error): U

        • Parameters

          • error: E

          Returns U

    Returns SyncEffect<T | U, never>

    • A new SyncEffect<T, never> that ensures success.

    Example

    const effect = SyncEffect(() => { throw new Error("Boom!"); }).recover(() => 0);
    console.log(effect.run()); // Ok(0)
    Copy

• run:function

  • run(): Result<T, E>

  • Runs the effect and returns a Result<T, E>.

    Returns Result<T, E>

    • A safe Result, encapsulating success (Ok<T>) or failure (Err<E>).

    Example

    const effect = SyncEffect(() => {
        if (Math.random() > 0.5) throw new Error("Failure");
        return 42;
    });
    console.log(effect.run()); // Either Ok(42) or Err(Error)
    Copy