Variable Readable

Type Declaration

• combine: <T extends readonly Readable<unknown>[]>(
      readables: T,
  ) => Readable<
      {
          [K in string
          | number
          | symbol]: T[K] extends Readable<A> ? A : never
      },
  >

  Alias for zipAll for backwards compatibility.

  Deprecated

  Use zipAll instead.

• debug: (
      id: string,
  ) => <A, R extends Readable<A>, E, Ctx>(
      self: Effect<R, E, Ctx>,
  ) => Effect<R, E, Scope | Ctx>

  Wrap a Readable-producing Effect to log its initial value and every subsequent change under the stax.readable subsystem. The wrapped Effect returns the original Readable unchanged — this is a pass-through observer.

  Zero cost at the default log level. Enable with Logger.withMinimumLogLevel(LogLevel.Debug) to see emissions. A lightweight stepping-stone toward the full Signal DevTools story (#86) — useful for quickly answering "what value does this Readable hold right now, and when does it change?" without wiring up a temporary subscriber.

  Example

  const val = yield* Signal.make(0).pipe(Readable.debug("my-val"));
  // Debug logs:
  //   stax.readable  "initial value"  { id: "my-val", value: 0 }
  //   stax.readable  "value changed"  { id: "my-val", value: 1 }
  //   ...
  Copy

  The subscription is forked into the current scope, so it's cleaned up when the enclosing effect's scope closes — no manual teardown needed.

• dedupe: <A>(self: Readable<A>) => Readable<A>

  Remove consecutive duplicate values using reference equality.

  Example

  const input = Readable.of(1);
  const deduped = input.pipe(Readable.dedupe);
  Copy

• dedupeWith: {
      <A>(equals: (a: A, b: A) => boolean): (self: Readable<A>) => Readable<A>;
      <A>(self: Readable<A>, equals: (a: A, b: A) => boolean): Readable<A>;
  }

  Remove consecutive duplicate values using a custom equality function.

  Example

  const users = Readable.of({ id: 1, name: "John" });
  const deduped = users.pipe(
    Readable.dedupeWith((a, b) => a.id === b.id)
  );
  Copy

• filter: {
      <A>(predicate: (a: A) => boolean): (self: Readable<A>) => Readable<A>;
      <A>(self: Readable<A>, predicate: (a: A) => boolean): Readable<A>;
  }

  Filter values from a Readable based on a predicate. Only values that pass the predicate are emitted.

  Note: The initial value must pass the predicate or the Readable will wait for the first passing value.

  Example

  const numbers = Readable.of(5);
  const positive = numbers.pipe(Readable.filter(n => n > 0));
  Copy

• flatMap: {
      <A, B>(f: (a: A) => Readable<B>): (self: Readable<A>) => Readable<B>;
      <A, B>(self: Readable<A>, f: (a: A) => Readable<B>): Readable<B>;
  }

  Chain Readables by mapping to another Readable and flattening. When the outer Readable changes, switches to the new inner Readable.

  Example

  const userId = Readable.of(1);
  const user = userId.pipe(Readable.flatMap(id => getUserReadable(id)));
  Copy

• fromStream: <A>(initial: A, stream: Stream<A>) => Readable<A>

  Create a Readable from an initial value and a stream of updates.

• id: <A>(value: A) => Readable<A>

  Alias for of - creates a constant Readable (identity lift).

• isReadable: (value: unknown) => value is Readable<unknown>

  Check if a value is a Readable.

• lift: <T extends Record<string, unknown>, R>(
      fn: (props: T) => R,
  ) => (
      props: { [K in string | number | symbol]: T[K] | Readable<T[K]> },
  ) => Readable<R>

  Lift a function that takes an object as its argument to work with potentially reactive properties.

  Example

  const fn = (props: { a: number; b: string }) => `${props.b}-${props.a}`;
  const lifted = Readable.lift(fn);
  
  const a = Readable.of(42);
  const result = lifted({ a, b: "hello" });
  // result: Readable<string>
  Copy

• make: <A>(get: Effect<A>, getChanges: () => Stream<A>) => Readable<A>

  Create a Readable from a getter effect and a changes stream factory.

• map: {
      <A, B>(f: (a: A) => B): (self: Readable<A>) => Readable<B>;
      <A, B>(self: Readable<A>, f: (a: A) => B): Readable<B>;
  }

  Transform a Readable's value using a mapping function.

  Example

  const count = Readable.of(5);
  const doubled = count.pipe(Readable.map(n => n * 2));
  // doubled.get returns 10
  Copy

• normalize: <A>(value: A | Readable<A>) => Readable<A>

  Normalize a value that may be static or reactive into a Readable. If the value is already a Readable, returns it unchanged. If the value is static, wraps it in a constant Readable.

  Example

  // Normalize a prop that can be static or reactive
  const disabled = Readable.normalize(props.disabled ?? false);
  // disabled is now Readable<boolean>
  Copy

• of: <A>(value: A) => Readable<A>

  Create a constant Readable from a value. The Readable always returns the same value and never changes.

  Example

  const constant = Readable.of(42);
  // constant.get returns 42, constant.changes is empty
  Copy

• tap: {
      <A, E, R>(
          f: (a: A) => Effect<void, E, R>,
      ): (self: Readable<A>) => Effect<void, E, Scope | R>;
      <A, E, R>(
          self: Readable<A>,
          f: (a: A) => Effect<void, E, R>,
      ): Effect<void, E, Scope | R>;
  }

  Run a side effect for each value emitted by the Readable. Subscribes in the background (forked into the current scope) and returns immediately. The subscription is automatically cleaned up when the scope closes.

  Example

  yield* Readable.tap(count, (n) => Effect.log(`Count: ${n}`));
  // Subscription runs in background, component continues rendering
  Copy

• TypeId: symbol

• zip: {
      <B>(that: Readable<B>): <A>(self: Readable<A>) => Readable<[A, B]>;
      <A, B>(self: Readable<A>, that: Readable<B>): Readable<[A, B]>;
  }

  Combine two Readables into a Readable of a tuple.

  Example

  const name = Readable.of("John");
  const age = Readable.of(30);
  const tuple = name.pipe(Readable.zip(age));
  // tuple: Readable<[string, number]>
  Copy

• zipAll: <T extends readonly Readable<unknown>[]>(
      readables: T,
  ) => Readable<
      {
          [K in string
          | number
          | symbol]: T[K] extends Readable<A> ? A : never
      },
  >

  Combine multiple Readables into a single Readable of a tuple. The combined Readable updates whenever any input changes.

  Example

  const firstName = Readable.of("John");
  const lastName = Readable.of("Doe");
  const age = Readable.of(30);
  
  const combined = Readable.zipAll([firstName, lastName, age]);
  // combined: Readable<[string, string, number]>
  Copy

• zipWith: {
      <A, B, C>(
          that: Readable<B>,
          f: (a: A, b: B) => C,
      ): (self: Readable<A>) => Readable<C>;
      <A, B, C>(
          self: Readable<A>,
          that: Readable<B>,
          f: (a: A, b: B) => C,
      ): Readable<C>;
  }

  Combine two Readables using a function.

  Example

  const firstName = Readable.of("John");
  const lastName = Readable.of("Doe");
  const fullName = firstName.pipe(
    Readable.zipWith(lastName, (first, last) => `${first} ${last}`)
  );
  Copy