Search documentation

Search by topic, API name, or import path.

GitHub ↗

variable / @typed/fx/Fx

zipWith

Zips two Fx streams in strict lockstep and combines each pair with a function. Emits f(a, b) when both streams have produced their next value.

Completion: Completes when the first of the two streams completes. Errors: The first failure from either stream fails the result.

Package version
2.0.0-beta.7
Category
Combining sources
Since
1.0.0

Follow one execution

Apply the callback once per lockstep pair; no stale right value is reused.

Fx timelinezipWith(left, right, pair)zipWith
OperatorzipWith(left, right, pair)
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 inherits zip’s two child runs and unbounded unmatched-value queues. The pure combiner adds no resource, error, or service requirement.

Source implementation · Learn the surrounding model

Compare all Fx timelines →

Import

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

Signatures

export declare const zipWith: {
    <A, A2, E2, R2, B>(that: Fx<A2, E2, R2>, f: (a: A, b: A2) => B): <E, R>(self: Fx<A, E, R>) => Fx<B, E | E2, R | R2>;
    <A, E, R, A2, E2, R2, B>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>, f: (a: A, b: A2) => B): Fx<B, E | E2, R | R2>;
};

Why

zipWith combines each strict pair immediately, preserving zip’s lockstep cardinality and ordering while avoiding a separate tuple mapping step.

Ownership and lifetime

It inherits zip’s two child runs and unbounded unmatched-value queues. The pure combiner adds no resource, error, or service requirement.

Examples

import { Fx } from "@typed/fx"
const sums = Fx.zipWith(Fx.fromIterable([1]), Fx.fromIterable([2]), (a, b) => a + b)

Other public imports

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

Source