# Fx.zipLeft

Zips two Fx streams in strict lockstep and emits only the left value.
Completes when the **first** of the two streams completes.

## Signatures

```ts
export declare const zipLeft: {
    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A, E | E2, R | R2>;
};
```

## Why

`zipLeft` uses the right source as a one-for-one pacing or validation partner while retaining the
left payload. It emits one left value per completed pair and preserves pair order.

## Ownership and lifetime

Both sources run concurrently. The first run to complete ends pairing and interrupts the other,
while consumer interruption stops both. A failure Cause is delivered to the Sink but does not by
itself end pairing; a producer may continue and supply a value afterward.

## Examples

```ts
import { Cause, Effect, Ref } from "effect"
import { Fx, Sink } from "@typed/fx"

const program = Effect.gen(function* () {
  const deliveries = yield* Ref.make<Array<string>>([])
  const left = Fx.make<number, string>((sink) =>
    sink.onFailure(Cause.fail("warning")).pipe(Effect.andThen(sink.onSuccess(1)))
  )
  yield* Fx.zipLeft(left, Fx.succeed("pair")).run(Sink.make(
    () => Ref.update(deliveries, (xs) => [...xs, "failure"]),
    (value) => Ref.update(deliveries, (xs) => [...xs, `value:${value}`])
  ))
  return yield* Ref.get(deliveries) // ["failure", "value:1"]
})
```