Search documentation

Search by topic, API name, or import path.

GitHub ↗

variable / @typed/fx

Fx.zipLatest

Zips two Fx streams by latest values: waits for both to emit at least once, then emits [left, right] whenever either stream emits (using the latest value from the other). No strict pairing; output count is the sum of emissions from both after the first pair.

Completion: Completes when both streams have completed. Errors: The first failure from either stream fails the result.

Package version
2.0.0-beta.13
Category
Combining sources
Since
1.0.0
Member of
Fx

Follow one execution

Pair current values after both initialize; either side can update the pair.

Fx timelinezipLatest(query, filter)zipLatest
OperatorzipLatest(query, filter)
Read this diagram

Follow each lane from left to right. Events stacked vertically share a tick; the green cursor marks the current time across every lane.

  • A value
    The text inside the pill is the emitted value.
  • Work starts
    The raised chevron starts an inner run (^ in the source).
  • The run returns
    The vertical bar ends this lane’s run.
  • A cause is delivered
    The exclamation mark belongs to this lane.
  • Work is interrupted
    The cross marks cancellation of this run.
  • Current time
    The line and diamond move together across all lanes.
  • Happening now
    A highlighted event is at the current tick.
  • Still ahead
    Muted, dashed values have not happened yet.
  • Time continues
    The lane’s arrow is not a return marker. An empty stretch can be quiet work that is still running.

Illustrated ticks start at 0. At 1×, one illustrated tick takes one second; captions specify real durations when timing matters. A cause or interruption belongs to its lane, and other work may continue. Scroll horizontally to inspect the rest of a long timeline.

It delegates to tuple: both sources run concurrently and retain one latest value each until both complete or the consumer is interrupted.

Source implementation · Learn the surrounding model

Compare all Fx timelines →

Import

import { Fx } from "@typed/fx";

Access Fx.zipLatest through the imported Fx export. Its declaration below describes the member.

This public exposure is a re-export. Its import path is supported; declaration documentation is shared with the other public exposures below.

Signatures

export declare const zipLatest: {
    <AR, ER, RR>(that: Fx<AR, ER, RR>): <AL, EL, RL>(self: Fx<AL, EL, RL>) => Fx<readonly [
        AL,
        AR
    ], EL | ER, RL | RR>;
    <AL, EL, RL, AR, ER, RR>(self: Fx<AL, EL, RL>, that: Fx<AR, ER, RR>): Fx<readonly [
        AL,
        AR
    ], EL | ER, RL | RR>;
};

Why

zipLatest combines independent sources as state: after both initialize, either update emits one pair containing both latest values. It does not enforce one-to-one pairing.

Ownership and lifetime

It delegates to tuple: both sources run concurrently and retain one latest value each until both complete or the consumer is interrupted.

Examples

import { Fx } from "@typed/fx"
const latest = Fx.zipLatest(Fx.succeed(1), Fx.succeed("ready"))

Other public imports

These import paths expose the same declaration. Each page retains its own public name and signature.

Source