@typed/fx 1.31.0 → 2.0.0-beta.0

package/README.md

@@ -1,5 +1,347 @@
 # @typed/fx
 
-> WIP
+> **Beta:** This package is in beta; APIs may change.
 
-Docs: https://tylors.github.io/typed/docs/fx
+`@typed/fx` provides reactive streams and state for Effect: **Fx** (streams with rich combinators and run functions), **Push**, **RefSubject** (and typed refs like RefArray, RefBoolean), **Subject**, **Sink**, and **Versioned**. Use it for event streams, reactive UI state, and composing effects as streams.
+
+## Dependencies
+
+- `effect`
+
+## API overview
+
+- **Fx** — Stream type `Fx.Fx<A, E, R>` with constructors (`succeed`, `fail`, `fromEffect`, `fromIterable`, `make`, `periodic`, etc.), combinators (`map`, `flatMap`, `filter`, `take`, `switchMap`, etc.), and run (`runPromise`, `collect`, `fork`, `observe`).
+- **Push** — Push-based stream abstraction.
+- **RefSubject** — Mutable reactive refs; `RefSubject.make(initial)`; typed helpers like `RefSubject.increment` / `RefSubject.decrement` for numbers; `RefArray`, `RefBoolean`, `RefOption`, etc.
+- **Subject** — Multicast subject for Fx streams.
+- **Sink** — Consumer abstraction with combinators.
+- **Versioned** — Versioned values.
+
+## Example
+
+```ts
+import { Fx } from "@typed/fx";
+
+Fx.fromIterable([1, 2, 3]).pipe(
+  Fx.filter((n) => n % 2 === 0),
+  Fx.map((n) => n * 2),
+  Fx.observe((n) => Effect.log(`emitted: ${n}`)),
+  Effect.runPromise
+);
+```
+
+See the [counter example](https://github.com/typed-smol/typed-smol/tree/main/examples/counter) for a full runnable app.
+
+## API reference
+
+- [Fx](#fx)
+- [Push](#push)
+- [RefSubject](#refsubject)
+- [Subject](#subject)
+- [Sink](#sink)
+- [Versioned](#versioned)
+
+### Fx
+
+Reactive stream type with concurrency, error handling, and context, integrated with Effect.
+
+**Type**
+
+- `Fx<A, E, R>` — Stream that emits `A`, can fail with `E`, requires context `R`; has `.run(sink)`.
+
+**Type-level**
+
+- `Fx.Success<T>`, `Fx.Error<T>`, `Fx.Services<T>` — Extract success, error, and context from an Fx type.
+- `Fx.Any`, `Fx.Variance` — Wildcard and variance markers.
+- `Fx.Service`, `Fx.Class` — Dependency-injection service/class for Fx.
+
+**Constructors**
+
+- `succeed(value)` — Emit a single value and complete.
+- `succeedNull` / `null` — Emit `null` and complete.
+- `succeedUndefined` / `undefined` — Emit `undefined` and complete.
+- `succeedVoid` / `void` — Emit void and complete.
+- `fail(error)` — Fail immediately with an error.
+- `failCause(cause)` — Fail immediately with a Cause.
+- `die(defect)` — Terminate with a defect.
+- `interrupt(id?)` — Create an Fx that interrupts.
+- `empty` — Emit nothing and complete immediately.
+- `never` — Run forever without emitting.
+- `fromEffect(effect)` — One-value Fx from an Effect (emit on success, fail on failure).
+- `fromIterable(iterable)` — Emit each element of the iterable then complete.
+- `fromYieldable(yieldable)` — Fx from any Yieldable (Effect, Promise, etc.).
+- `fromSchedule(schedule)` — Emit `void` each time the schedule fires.
+- `fromFailures(failures)` — Fx that fails with combined failures from an iterable.
+- `make(run)` — Low-level: build Fx from a function that runs a Sink.
+- `callback(run)` — Build Fx from a callback; receives `Emit` (succeed, failCause, fail, die, done).
+- `at(value, delay)` — Emit one value after a delay.
+- `periodic(period)` — Emit `void` on a fixed interval.
+- `fn(body, ...pipeables)` — Effect.fn-style for Fx (body can return Fx); optional name/span.
+
+**Combinators**
+
+- `map(f)` — Transform emitted values.
+- `mapEffect(f)` — Transform with an Effect.
+- `flatMap(f)` — Map to inner Fx and merge (concurrent; like mergeMap).
+- `flatMapEffect(f)` — FlatMap with an Effect returning Fx.
+- `flatMapConcurrently(f, concurrency?)` — FlatMap with a concurrency limit.
+- `flatMapConcurrentlyEffect(f, concurrency?)` — Same with Effect-based inner Fx.
+- `switchMap(f)` — Map to inner Fx and switch to latest (cancels previous).
+- `switchMapEffect(f)` — SwitchMap with Effect returning Fx.
+- `exhaustMap(f)` — Map to inner Fx, ignore new outer values while inner runs.
+- `exhaustMapEffect(f)` — ExhaustMap with Effect returning Fx.
+- `exhaustLatestMap(f)` — Like exhaustMap but cancel previous inner when new outer arrives.
+- `exhaustLatestMapEffect(f)` — ExhaustLatestMap with Effect returning Fx.
+- `filter(f)` — Keep only values satisfying the predicate.
+- `filterEffect(f)` — Filter with an Effect predicate.
+- `filterMap(f)` — Filter and map to Option; compact.
+- `filterMapEffect(f)` — FilterMap with Effect.
+- `compact` — Filter out `None`, unwrap `Some`.
+- `take(n)` — Take first n elements.
+- `takeUntil(fx)` — Take until another Fx emits.
+- `skip(n)` — Skip first n elements.
+- `slice(options)` — Skip/take by bounds.
+- `skipRepeats` — Drop consecutive duplicates (Equal).
+- `skipRepeatsWith(equiv)` — Drop consecutive duplicates with custom equivalence.
+- `mergeAll(fxs)` — Merge multiple Fx streams.
+- `mergeOrdered(fxs)` — Merge with ordering guarantees.
+- `catch(f)` — Recover from errors.
+- `onError(f)` — Run an effect on failure.
+- `onExit(f)` — Run an effect on exit (success/failure/interrupt).
+- `onInterrupt(f)` — Run an effect on interrupt.
+- `ensuring(effect)` — Run effect when Fx ends (success, failure, or interrupt).
+- `provide(services)` — Provide context to the Fx.
+- `when(condition, fx)` — Run Fx only when condition holds.
+- `unwrap` — Unwrap Fx of Fx (flatten one level).
+- `unwrapScoped` — Unwrap with Scope for inner Fx.
+- `gen(f)` — Build Fx from a generator (yield Effects, return Fx).
+- `genScoped(f)` — gen with Scope.
+- `loop(initial, f)` — Loop with state and Option for continue/exit.
+- `loopEffect(initial, f)` — Loop with Effect.
+- `loopCause(initial, f)` — Loop with Cause handling.
+- `loopCauseEffect(initial, f)` — Loop with Cause and Effect.
+- `filterMapLoop(initial, f)` — Loop yielding Option.
+- `filterMapLoopEffect(initial, f)` — filterMapLoop with Effect.
+- `filterMapLoopCause(initial, f)` — filterMapLoop with Cause.
+- `filterMapLoopCauseEffect(initial, f)` — filterMapLoop with Cause and Effect.
+- `keyed(keyFn, f)` — Keyed stream (e.g. by id) with inner Fx per key.
+- `tapEffect(f)` — Run effect for each value, pass value through.
+- `exit` — Turn Fx of Exit into Fx that fails/succeeds accordingly.
+- `causes` — Expose failures as Cause emissions.
+- `continueWith(f)` — When Fx ends, continue with another Fx.
+- `flip` — Swap success and error types.
+- `tuple(...fxs)` — Combine Fx streams into tuple Fx.
+- `withSpan(name?, options?)` — Add tracing span around the Fx.
+
+**Run**
+
+- `runPromise(fx, options?)` — Run to completion; Promise rejects on failure.
+- `runPromiseExit(fx, options?)` — Run to completion; Promise resolves to Exit.
+- `collectAll(fx)` — Collect all emitted values into an array (Effect).
+- `collectAllFork(fx)` — Fork collection of all values (returns Fiber of array).
+- `collectUpTo(fx, n)` — Collect at most n values.
+- `collectUpToFork(fx, n)` — Fork collectUpTo.
+- `first(fx)` — Effect that yields first value as Option (None if empty).
+- `fork(fx, options?)` — Run Fx in a background fiber; returns Effect of Fiber.
+- `runFork(fx, options?)` — Run Fx in a new fiber via Effect.runFork.
+- `observe(fx, f)` — Run callback for each value; returns Effect that completes when stream ends.
+- `drain(fx)` — Run Fx, discard values (Effect completes when stream ends).
+- `drainLayer(fx)` — Layer that forks and drains the Fx.
+- `observeLayer(fx, f)` — Layer that observes the Fx with the given callback.
+
+**Stream interop**
+
+- `toStream(fx, options?)` — Convert Fx to Effect Stream.
+- `fromStream(stream, options?)` — Convert Effect Stream to Fx.
+
+---
+
+### Push
+
+Push-based abstraction that is both a Sink (input) and an Fx (output).
+
+**Type**
+
+- `Push<A, E, R, B, E2, R2>` — Consumes `A` (Sink) and produces `B` (Fx); input and output types are independent.
+
+**Constructor**
+
+- `Push.make(sink, fx)` — Create a Push from a Sink and an Fx (dual: can be called as `make(fx)(sink)`).
+
+**Service**
+
+- `Push.Service`, `Push.Class` — Dependency-injection for Push.
+
+---
+
+### RefSubject
+
+Mutable reactive reference: observable state that can be read (as Effect), updated, and subscribed to (as Fx).
+
+**Types**
+
+- `RefSubject<A, E, R>` — Mutable ref; extends `Computed` and `Subject`; has `updates(transaction)` and `interrupt`.
+- `Computed<A, E, R>` — Read-only derived value (Fx + Effect); emits and samples transformed value.
+- `Filtered<A, E, R>` — Computed over Option; may not always have a value.
+- `GetSetDelete<A, E, R>` — Interface with get/set/delete for use inside `updates`.
+
+**Constructors**
+
+- `make(initial, options?)` — Create RefSubject from value, Effect, or Fx; options include `eq` (equivalence).
+- `fromEffect(effect)` — RefSubject driven by an Effect (e.g. initial value from async source).
+- `fromFx(fx)` — RefSubject that follows an Fx stream.
+- `fromStream(stream)` — RefSubject from an Effect Stream.
+
+**Core operations**
+
+- `set(ref, value)` — Set current value.
+- `reset(ref)` — Reset to initial (if any); returns previous value as Option.
+- `update(ref, f)` — Update with a pure function.
+- `updateEffect(ref, f)` — Update with an Effect.
+- `modify(ref, f)` — Modify and return a result (pure).
+- `modifyEffect(ref, f)` — Modify with an Effect.
+- `runUpdates(ref, f)` — Run an effect that can read/update the ref (transactional).
+- `increment(ref)` — Add 1 to a number RefSubject; returns new value.
+- `decrement(ref)` — Subtract 1 from a number RefSubject; returns new value.
+- `proxy(ref)` — Create a proxy RefSubject that forwards to the given ref.
+- `isRefSubject(value)` — Type guard for RefSubject.
+
+**Derived**
+
+- `map(ref, f)` — Computed that applies f to the value.
+- `mapEffect(ref, f)` — Computed with Effect transformation.
+- `filterMap(ref, f)` — Filtered computed (Option).
+- `filterMapEffect(ref, f)` — FilterMap with Effect.
+- `compact(ref)` — Filtered that strips Option.
+- `slice(ref, options)` — Slice over iterable-like ref.
+- `transform(ref, transformFx, transformGet)` — General transform of a RefSubject/Versioned.
+- `makeComputed(input, f)` — Build a Computed from a Versioned and an Effect function.
+- `makeFiltered(input, f)` — Build a Filtered from a Versioned and an Effect returning Option.
+- `struct(refs)` — Combine refs into a struct RefSubject.
+- `tuple(refs)` — Combine refs into a tuple RefSubject.
+- `computedFromService(service)`, `filteredFromService(service)` — Computed/Filtered from a service.
+
+**Typed refs** (each has `make` and domain-specific helpers)
+
+- `RefArray` — Array ref; e.g. prepend, append, remove.
+- `RefBoolean` — Boolean ref; e.g. toggle, setTrue, setFalse.
+- `RefOption` — Option ref.
+- `RefResult` — Result ref.
+- `RefString` — String ref.
+- `RefBigInt` — BigInt ref.
+- `RefBigDecimal` — BigDecimal ref.
+- `RefDuration` — Duration ref.
+- `RefDateTime` — DateTime ref.
+- `RefCause` — Cause ref.
+- `RefChunk` — Chunk ref.
+- `RefHashMap` — HashMap ref.
+- `RefHashSet` — HashSet ref.
+- `RefRecord` — Record ref.
+- `RefStruct` — Struct ref.
+- `RefTuple` — Tuple ref.
+- `RefGraph` — Graph ref.
+- `RefHashRing` — HashRing ref.
+- `RefTrie` — Trie ref.
+- `RefIterable` — Iterable ref.
+
+---
+
+### Subject
+
+Multicast point: both an Fx and a Sink; multiple subscribers share one run of the source.
+
+**Type**
+
+- `Subject<A, E, R>` — Implements `Fx<A, E, R>` and `Sink<A, E, R>`; has `subscriberCount` (Effect) and `interrupt`.
+
+**Constructors**
+
+- `Subject.make(replay?)` — Create a subject; optional replay buffer size.
+- `Subject.unsafeMake(replay?)` — Create without Scope (unsafe for cleanup).
+
+**Combinators**
+
+- `Subject.share(fx, subject)` — Multicast Fx through a subject (one run, many subscribers).
+- `Subject.multicast(fx)` — Share Fx with a fresh subject.
+- `Subject.hold(fx)` — Fx that holds last value for late subscribers.
+- `Subject.replay(fx, n)` — Replay last n values to new subscribers.
+
+**Service**
+
+- `Subject.Service`, `Subject.Class` — Dependency-injection for Subject.
+
+---
+
+### Sink
+
+Consumer of values: two callbacks, one for success and one for failure.
+
+**Type**
+
+- `Sink<A, E, R>` — `{ onSuccess: (value: A) => Effect, onFailure: (cause: Cause<E>) => Effect }`.
+- `Sink.WithEarlyExit<A, E, R>` — Adds `earlyExit` for early termination.
+- `Sink.WithState<A, E, R, B>` — Sink with state Ref.
+- `Sink.WithStateSemaphore<A, E, R, B>` — Sink with state and transactional updates.
+
+**Constructor**
+
+- `Sink.make(onFailure, onSuccess)` — Build a Sink from the two callbacks.
+
+**Combinators**
+
+- `map(sink, f)` — Transform values before they reach the sink.
+- `filterMap(sink, f)` — Filter and map (Option).
+- `compact(sink)` — Sink for Option, forward only Some.
+- `filter(sink, f)` — Filter values.
+- `withEarlyExit(sink, earlyExit)` — Add early-exit capability.
+- `withState(sink, initial, f)` — Stateful sink.
+- `withStateSemaphore(sink, initial, f)` — Stateful sink with semaphore for transactional updates.
+- `loop(sink, initial, f)` — Loop over sink with state.
+- `loopCause(sink, initial, f)` — Loop with Cause handling.
+- `filterMapLoop(sink, initial, f)` — Loop with filterMap.
+- `filterMapLoopCause(sink, initial, f)` — filterMapLoop with Cause.
+- `loopEffect(sink, initial, f)` — Loop with Effect.
+- `filterMapLoopEffect(sink, initial, f)` — filterMapLoop with Effect.
+- `loopCauseEffect(sink, initial, f)` — loopCause with Effect.
+- `filterMapLoopCauseEffect(sink, initial, f)` — Full variant with Cause and Effect.
+- `slice(sink, options)` — Skip/take at the Sink level.
+- `mapEffect(sink, f)` — Effectful map.
+- `filterMapEffect(sink, f)` — Effectful filterMap.
+- `filterEffect(sink, f)` — Effectful filter.
+- `tapEffect(sink, f)` — Tap with Effect, pass value through.
+- `flip(sink)` — Swap success and error types.
+- `exit(sink)` — Sink for Exit (success/failure).
+- `dropAfter(sink, n)` — Drop values after the nth.
+- `skipInterrupt(sink)` — Ignore interrupt at the Sink.
+
+**Service**
+
+- `Sink.Service`, `Sink.Class` — Dependency-injection for Sink.
+
+---
+
+### Versioned
+
+Value that changes over time with a version number; both an Fx (subscribe to changes) and an Effect (sample current value).
+
+**Type**
+
+- `Versioned<R1, E1, A2, E2, R2, A3, E3, R3>` — Fx emits `A2`; sampling yields `A3`; has `version` (Effect of number) and `interrupt`.
+
+**Type-level**
+
+- `Versioned.Unify<T>` — Unify a Versioned type.
+- `Versioned.VersionContext<T>` — Context required to get version.
+- `Versioned.VersionError<T>` — Error type of the version effect.
+
+**Constructor**
+
+- `Versioned.make(version, fx, effect)` — Build Versioned from version effect, update stream (Fx), and current-value effect.
+
+**Combinators**
+
+- `Versioned.transform(input, transformFx, transformGet)` — Transform the Fx and the sampling effect into a new Versioned.
+
+**Service**
+
+- `Versioned.Service`, `Versioned.Class` — Dependency-injection for Versioned.

package/dist/Fx/Fx.d.ts

@@ -0,0 +1,96 @@
+import * as Effect from "effect/Effect";
+import type { Layer } from "effect/Layer";
+import { type Pipeable } from "effect/Pipeable";
+import type * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type * as Types from "effect/Types";
+import type * as Sink from "../Sink/Sink.js";
+import { FxTypeId } from "./TypeId.js";
+/**
+ * `Fx` is a reactive stream of values that supports concurrency, error handling,
+ * and context management, fully integrated with the Effect ecosystem.
+ *
+ * Conceptually, an `Fx<A, E, R>` is a push-based stream that:
+ * - Emits values of type `A`
+ * - Can fail with an error of type `E`
+ * - Requires a context/environment of type `R`
+ *
+ * Unlike a standard `Effect` which produces a single value, `Fx` can produce
+ * 0, 1, or many values over time. It is similar to RxJS Observables or
+ * AsyncIterables, but built on top of Effect's fiber-based concurrency model.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Fx<A, E = never, R = never> extends Pipeable {
+    readonly [FxTypeId]: Fx.Variance<A, E, R>;
+    /**
+     * Runs the Fx stream by providing a Sink to consume the values.
+     * The result is an Effect that runs the stream process.
+     */
+    readonly run: <RSink>(sink: Sink.Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>;
+}
+export declare namespace Fx {
+    /**
+     * Any Fx type with wildcards.
+     * @since 1.0.0
+     * @category models
+     */
+    type Any = Fx<any, any, any>;
+    /**
+     * Variance markers for Fx types.
+     * @since 1.0.0
+     * @category models
+     */
+    interface Variance<A, E, R> {
+        readonly _A: Types.Covariant<A>;
+        readonly _E: Types.Covariant<E>;
+        readonly _R: Types.Covariant<R>;
+    }
+    /**
+     * Extract the success type from an Fx.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Success<T> = [T] extends [never] ? never : T extends Fx<infer _A, infer _E, infer _R> ? _A : never;
+    /**
+     * Extract the error type from an Fx.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Error<T> = [T] extends [never] ? never : T extends Fx<infer _A, infer _E, infer _R> ? _E : never;
+    /**
+     * Extract the required services from an Fx.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Services<T> = [T] extends [never] ? never : [T] extends [Fx<infer _A, infer _E, infer _R>] ? _R : never;
+    interface Service<Self, Id extends string, A, E> extends Fx<A, E, Self> {
+        readonly id: Id;
+        readonly service: ServiceMap.Service<Self, Fx<A, E>>;
+        readonly make: <R = never>(fx: Fx<A, E, R> | Effect.Effect<Fx<A, E, R>, E, R>) => Layer<Self, E, Exclude<R, Scope.Scope>>;
+    }
+    interface Class<Self, Id extends string, A, E> extends Service<Self, Id, A, E> {
+        new (): Service<Self, Id, A, E>;
+    }
+}
+/**
+ * Extract the success type from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Success<T> = Fx.Success<T>;
+/**
+ * Extract the error type from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Error<T> = Fx.Error<T>;
+/**
+ * Extract the required services from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Services<T> = Fx.Services<T>;
+export declare function Service<Self, A, E = never>(): <const Id extends string>(id: Id) => Fx.Class<Self, Id, A, E>;
+//# sourceMappingURL=Fx.d.ts.map

package/dist/Fx/Fx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fx.d.ts","sourceRoot":"","sources":["../../src/Fx/Fx.ts"],"names":[],"mappings":"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"}

package/dist/Fx/Fx.js

@@ -0,0 +1,35 @@
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import { effect } from "effect/Layer";
+import { pipeArguments } from "effect/Pipeable";
+import * as ServiceMap from "effect/ServiceMap";
+import { provideServices } from "./combinators/provide.js";
+import { FxTypeId, isFx } from "./TypeId.js";
+const VARIANCE = {
+    _A: identity,
+    _E: identity,
+    _R: identity,
+};
+export function Service() {
+    return (id) => {
+        const service = ServiceMap.Service(id);
+        // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+        return class FxService {
+            static id = id;
+            static service = service;
+            static make = (fx) => effect(service, Effect.gen(function* () {
+                const services = yield* Effect.services();
+                const result = isFx(fx) ? fx : yield* fx;
+                return provideServices(result, services);
+            }));
+            static [FxTypeId] = VARIANCE;
+            static pipe = function () {
+                return pipeArguments(this, arguments);
+            };
+            static run = (sink) => Effect.flatMap(service.asEffect(), (fx) => fx.run(sink));
+            constructor() {
+                return FxService;
+            }
+        };
+    };
+}

package/dist/Fx/TypeId.d.ts

@@ -0,0 +1,20 @@
+import type { Fx } from "./Fx.js";
+/**
+ * The unique type identifier for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export declare const FxTypeId: unique symbol;
+/**
+ * The unique type identifier type for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export type FxTypeId = typeof FxTypeId;
+/**
+ * Checks if a value is an Fx.
+ * @since 1.0.0
+ * @category guards
+ */
+export declare function isFx(u: unknown): u is Fx<any, any, any>;
+//# sourceMappingURL=TypeId.d.ts.map

package/dist/Fx/TypeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeId.d.ts","sourceRoot":"","sources":["../../src/Fx/TypeId.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,eAA6B,CAAC;AAEnD;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC;AAEvC;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAEvD"}

package/dist/Fx/TypeId.js

@@ -0,0 +1,15 @@
+import { hasProperty } from "effect/Predicate";
+/**
+ * The unique type identifier for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export const FxTypeId = Symbol.for("@typed/fx/Fx");
+/**
+ * Checks if a value is an Fx.
+ * @since 1.0.0
+ * @category guards
+ */
+export function isFx(u) {
+    return hasProperty(u, FxTypeId);
+}

package/dist/Fx/combinators/catch.d.ts

@@ -0,0 +1,53 @@
+import type * as Arr from "effect/Array";
+import * as Cause from "effect/Cause";
+import type { ExcludeTag, ExtractTag, NoInfer, Tags } from "effect/Types";
+import type { Fx } from "../Fx.js";
+/**
+ * Recovers from a typed failure of an Fx by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catch` / `Effect.catchAll` (catches `Cause.Fail` only).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const catch_: {
+    <E, A2, E2, R2>(f: (e: E) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
+};
+export { catch_ as catch };
+/**
+ * An alias for {@link catch}.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const catchAll: {
+    <E, A2, E2, R2>(f: (e: E) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
+};
+/**
+ * Recovers from *any* failure cause of an Fx (including defects and interrupts)
+ * by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catchCause`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const catchCause: {
+    <E, A2, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
+};
+/**
+ * Recovers from a typed failure by matching on the `_tag` field of the error.
+ *
+ * Mirrors `Effect.catchTag`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const catchTag: {
+    <const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, E, A2, E2, R2>(k: K, f: (e: ExtractTag<NoInfer<E>, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>, R | R2>;
+    <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(self: Fx<A, E, R>, k: K, f: (e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>) => Fx<A2, E2, R2>): Fx<A | A2, E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>, R | R2>;
+};
+//# sourceMappingURL=catch.d.ts.map

package/dist/Fx/combinators/catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/catch.ts"],"names":[],"mappings":"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"}

package/dist/Fx/combinators/catch.js

@@ -0,0 +1,69 @@
+import * as Cause from "effect/Cause";
+import { dual } from "effect/Function";
+import * as Result from "effect/Result";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+const hasTag = (u) => typeof u === "object" &&
+    u !== null &&
+    "_tag" in u &&
+    typeof u["_tag"] === "string";
+const matchesTag = (tag, error) => {
+    if (!hasTag(error))
+        return false;
+    if (typeof tag === "string")
+        return error._tag === tag;
+    return tag.some((t) => t === error._tag);
+};
+/**
+ * Recovers from a typed failure of an Fx by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catch` / `Effect.catchAll` (catches `Cause.Fail` only).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catch_ = dual(2, (self, f) => make((sink) => self.run(makeSink((cause) => {
+    const result = Cause.findFail(cause);
+    if (Result.isFailure(result)) {
+        return sink.onFailure(result.failure);
+    }
+    return f(result.success.error).run(sink);
+}, sink.onSuccess))));
+export { catch_ as catch };
+/**
+ * An alias for {@link catch}.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchAll = catch_;
+/**
+ * Recovers from *any* failure cause of an Fx (including defects and interrupts)
+ * by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catchCause`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchCause = dual(2, (self, f) => make((sink) => self.run(makeSink((cause) => f(cause).run(sink), sink.onSuccess))));
+/**
+ * Recovers from a typed failure by matching on the `_tag` field of the error.
+ *
+ * Mirrors `Effect.catchTag`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchTag = dual(3, (self, k, f) => make((sink) => self.run(makeSink((cause) => {
+    const result = Cause.findFail(cause);
+    if (Result.isFailure(result)) {
+        return sink.onFailure(result.failure);
+    }
+    else if (matchesTag(k, result.success.error)) {
+        return f(result.success.error).run(sink);
+    }
+    else {
+        return sink.onFailure(cause);
+    }
+}, sink.onSuccess))));

package/dist/Fx/combinators/causes.d.ts

@@ -0,0 +1,12 @@
+import type * as Cause from "effect/Cause";
+import type { Fx } from "../Fx.js";
+/**
+ * Emits only the failure causes from an Fx, discarding successful values.
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Cause<E>`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const causes: <A, E, R>(fx: Fx<A, E, R>) => Fx<Cause.Cause<E>, never, R>;
+//# sourceMappingURL=causes.d.ts.map