effect 3.6.4 → 3.6.6

package/src/internal/metric.ts

@@ -20,6 +20,7 @@ import * as _effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as metricBoundaries from "./metric/boundaries.js"
 import * as metricKey from "./metric/key.js"
+import * as metricKeyType from "./metric/keyType.js"
 import * as metricLabel from "./metric/label.js"
 import * as metricRegistry from "./metric/registry.js"
 
@@ -50,7 +51,8 @@ export const globalMetricRegistry: MetricRegistry.MetricRegistry = globalValue(
 export const make: Metric.MetricApply = function<Type, In, Out>(
   keyType: Type,
   unsafeUpdate: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void,
-  unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out
+  unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out,
+  unsafeModify: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void
 ): Metric.Metric<Type, In, Out> {
   const metric: Metric.Metric<Type, In, Out> = Object.assign(
     <A extends In, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
@@ -60,6 +62,7 @@ export const make: Metric.MetricApply = function<Type, In, Out>(
       keyType,
       unsafeUpdate,
       unsafeValue,
+      unsafeModify,
       register() {
         this.unsafeValue([])
         return this as any
@@ -80,7 +83,8 @@ export const mapInput = dual<
   make(
     self.keyType,
     (input, extraTags) => self.unsafeUpdate(f(input), extraTags),
-    self.unsafeValue
+    self.unsafeValue,
+    (input, extraTags) => self.unsafeModify(f(input), extraTags)
   ))
 
 /** @internal */
@@ -149,7 +153,8 @@ export const fromMetricKey = <Type extends MetricKeyType.MetricKeyType<any, any>
   return make(
     key.keyType,
     (input, extraTags) => hook(extraTags).update(input),
-    (extraTags) => hook(extraTags).get()
+    (extraTags) => hook(extraTags).get(),
+    (input, extraTags) => hook(extraTags).modify(input)
   )
 }
 
@@ -171,20 +176,30 @@ export const histogram = (name: string, boundaries: MetricBoundaries.MetricBound
 
 /* @internal */
 export const increment = (
-  self: Metric.Metric.Counter<number> | Metric.Metric.Counter<bigint>
-): Effect.Effect<void> => update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
+  self:
+    | Metric.Metric.Counter<number>
+    | Metric.Metric.Counter<bigint>
+    | Metric.Metric.Gauge<number>
+    | Metric.Metric.Gauge<bigint>
+): Effect.Effect<void> =>
+  metricKeyType.isCounterKey(self.keyType)
+    ? update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
+    : modify(self as Metric.Metric.Gauge<number>, self.keyType.bigint ? BigInt(1) as any : 1)
 
 /* @internal */
 export const incrementBy = dual<
   {
-    (amount: number): (self: Metric.Metric.Counter<number>) => Effect.Effect<void>
-    (amount: bigint): (self: Metric.Metric.Counter<bigint>) => Effect.Effect<void>
+    (amount: number): (self: Metric.Metric.Counter<number> | Metric.Metric.Counter<number>) => Effect.Effect<void>
+    (amount: bigint): (self: Metric.Metric.Counter<bigint> | Metric.Metric.Gauge<bigint>) => Effect.Effect<void>
   },
   {
-    (self: Metric.Metric.Counter<number>, amount: number): Effect.Effect<void>
-    (self: Metric.Metric.Counter<bigint>, amount: bigint): Effect.Effect<void>
+    (self: Metric.Metric.Counter<number> | Metric.Metric.Gauge<number>, amount: number): Effect.Effect<void>
+    (self: Metric.Metric.Counter<bigint> | Metric.Metric.Gauge<bigint>, amount: bigint): Effect.Effect<void>
   }
->(2, (self, amount) => update(self as any, amount))
+>(2, (self, amount) =>
+  metricKeyType.isCounterKey(self.keyType)
+    ? update(self as any, amount)
+    : modify(self as any, amount))
 
 /** @internal */
 export const map = dual<
@@ -194,7 +209,8 @@ export const map = dual<
   make(
     self.keyType,
     self.unsafeUpdate,
-    (extraTags) => f(self.unsafeValue(extraTags))
+    (extraTags) => f(self.unsafeValue(extraTags)),
+    self.unsafeModify
   ))
 
 /** @internal */
@@ -208,7 +224,23 @@ export const mapType = dual<
     self: Metric.Metric<Type, In, Out>,
     f: (type: Type) => Type2
   ) => Metric.Metric<Type2, In, Out>
->(2, (self, f) => make(f(self.keyType), self.unsafeUpdate, self.unsafeValue))
+>(2, (self, f) =>
+  make(
+    f(self.keyType),
+    self.unsafeUpdate,
+    self.unsafeValue,
+    self.unsafeModify
+  ))
+
+/** @internal */
+export const modify = dual<
+  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Effect.Effect<void>,
+  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Effect.Effect<void>
+>(2, (self, input) =>
+  core.fiberRefGetWith(
+    core.currentMetricLabels,
+    (tags) => core.sync(() => self.unsafeModify(input, tags))
+  ))
 
 /* @internal */
 export const set = dual<
@@ -223,11 +255,12 @@ export const set = dual<
 >(2, (self, value) => update(self as any, value))
 
 /** @internal */
-export const succeed = <Out>(out: Out): Metric.Metric<void, unknown, Out> => make(void 0 as void, constVoid, () => out)
+export const succeed = <Out>(out: Out): Metric.Metric<void, unknown, Out> =>
+  make(void 0 as void, constVoid, () => out, constVoid)
 
 /** @internal */
 export const sync = <Out>(evaluate: LazyArg<Out>): Metric.Metric<void, unknown, Out> =>
-  make(void 0 as void, constVoid, evaluate)
+  make(void 0 as void, constVoid, evaluate, constVoid)
 
 /** @internal */
 export const summary = (
@@ -277,7 +310,12 @@ export const taggedWithLabelsInput = dual<
           input,
           Arr.union(f(input), extraTags)
         ),
-      self.unsafeValue
+      self.unsafeValue,
+      (input, extraTags) =>
+        self.unsafeModify(
+          input,
+          Arr.union(f(input), extraTags)
+        )
     ),
     constVoid
   ))
@@ -295,7 +333,8 @@ export const taggedWithLabels = dual<
   return make(
     self.keyType,
     (input, extraTags1) => self.unsafeUpdate(input, Arr.union(extraTags, extraTags1)),
-    (extraTags1) => self.unsafeValue(Arr.union(extraTags, extraTags1))
+    (extraTags1) => self.unsafeValue(Arr.union(extraTags, extraTags1)),
+    (input, extraTags1) => self.unsafeModify(input, Arr.union(extraTags, extraTags1))
   )
 })
 
@@ -520,7 +559,12 @@ export const zip = dual<
         self.unsafeUpdate(l, extraTags)
         that.unsafeUpdate(r, extraTags)
       },
-      (extraTags) => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)]
+      (extraTags) => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)],
+      (input: readonly [In, In2], extraTags) => {
+        const [l, r] = input
+        self.unsafeModify(l, extraTags)
+        that.unsafeModify(r, extraTags)
+      }
     )
 )
 

package/src/internal/stream.ts

@@ -1680,74 +1680,74 @@ export const concatAll = <A, E, R>(streams: Chunk.Chunk<Stream.Stream<A, E, R>>)
   suspend(() => pipe(streams, Chunk.reduce(empty as Stream.Stream<A, E, R>, (x, y) => concat(y)(x))))
 
 /** @internal */
-export const cross = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<[A, A2], E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<[A, A2], E2 | E, R2 | R>
->(
+export const cross: {
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<[AL, AR], EL | ER, RL | RR>
+  <AL, ER, RR, AR, EL, RL>(
+    left: Stream.Stream<AL, ER, RR>,
+    right: Stream.Stream<AR, EL, RL>
+  ): Stream.Stream<[AL, AR], EL | ER, RL | RR>
+} = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<[A, A2], E2 | E, R2 | R> => pipe(self, crossWith(that, (a, a2) => [a, a2]))
+  <AL, ER, RR, AR, EL, RL>(
+    left: Stream.Stream<AL, ER, RR>,
+    right: Stream.Stream<AR, EL, RL>
+  ): Stream.Stream<[AL, AR], EL | ER, RL | RR> => pipe(left, crossWith(right, (a, a2) => [a, a2]))
 )
 
 /** @internal */
-export const crossLeft = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<A, E2 | E, R2 | R>
->(
+export const crossLeft: {
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<AL, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AL, EL | ER, RL | RR>
+} = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<A, E2 | E, R2 | R> => pipe(self, crossWith(that, (a, _) => a))
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AL, EL | ER, RL | RR> => pipe(left, crossWith(right, (a, _) => a))
 )
 
 /** @internal */
-export const crossRight = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<A2, E2 | E, R2 | R>
->(
+export const crossRight: {
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<AR, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AR, EL | ER, RL | RR>
+} = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<A2, E2 | E, R2 | R> => flatMap(self, () => that)
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AR, EL | ER, RL | RR> => flatMap(left, () => right)
 )
 
 /** @internal */
-export const crossWith = dual<
-  <B, E2, R2, A, C>(
-    that: Stream.Stream<B, E2, R2>,
-    f: (a: A, b: B) => C
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E2 | E, R2 | R>,
-  <A, E, R, B, E2, R2, C>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<B, E2, R2>,
-    f: (a: A, b: B) => C
-  ) => Stream.Stream<C, E2 | E, R2 | R>
->(
+export const crossWith: {
+  <AR, ER, RR, AL, A>(
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): <EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<A, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream.Stream<A, EL | ER, RL | RR>
+} = dual(
   3,
-  <A, E, R, B, E2, R2, C>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<B, E2, R2>,
-    f: (a: A, b: B) => C
-  ): Stream.Stream<C, E2 | E, R2 | R> => pipe(self, flatMap((a) => pipe(that, map((b) => f(a, b)))))
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream.Stream<A, EL | ER, RL | RR> => pipe(left, flatMap((a) => pipe(right, map((b) => f(a, b)))))
 )
 
 /** @internal */
@@ -7891,20 +7891,20 @@ export const zipAllWith = dual<
 )
 
 /** @internal */
-export const zipLatest = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<[A, A2], E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<[A, A2], E2 | E, R2 | R>
->(
+export const zipLatest: {
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<[AL, AR], EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<[AL, AR], EL | ER, RL | RR>
+} = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<[A, A2], E2 | E, R2 | R> => pipe(self, zipLatestWith(that, (a, a2) => [a, a2]))
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<[AL, AR], EL | ER, RL | RR> => pipe(left, zipLatestWith(right, (a, a2) => [a, a2]))
 )
 
 export const zipLatestAll = <T extends ReadonlyArray<Stream.Stream<any, any, any>>>(
@@ -7929,34 +7929,34 @@ export const zipLatestAll = <T extends ReadonlyArray<Stream.Stream<any, any, any
 }
 
 /** @internal */
-export const zipLatestWith = dual<
-  <A2, E2, R2, A, A3>(
-    that: Stream.Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A3, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2, A3>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ) => Stream.Stream<A3, E2 | E, R2 | R>
->(
+export const zipLatestWith: {
+  <AR, ER, RR, AL, A>(
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): <EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<A, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream.Stream<A, EL | ER, RL | RR>
+} = dual(
   3,
-  <A, E, R, A2, E2, R2, A3>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ): Stream.Stream<A3, E2 | E, R2 | R> => {
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream.Stream<A, EL | ER, RL | RR> => {
     const pullNonEmpty = <_R, _E, _A>(
       pull: Effect.Effect<Chunk.Chunk<_A>, Option.Option<_E>, _R>
     ): Effect.Effect<Chunk.Chunk<_A>, Option.Option<_E>, _R> =>
       pipe(pull, Effect.flatMap((chunk) => Chunk.isEmpty(chunk) ? pullNonEmpty(pull) : Effect.succeed(chunk)))
     return pipe(
-      toPull(self),
+      toPull(left),
       Effect.map(pullNonEmpty),
-      Effect.zip(pipe(toPull(that), Effect.map(pullNonEmpty))),
+      Effect.zip(pipe(toPull(right), Effect.map(pullNonEmpty))),
       Effect.flatMap(([left, right]) =>
         pipe(
-          fromEffectOption<readonly [Chunk.Chunk<A>, Chunk.Chunk<A2>, boolean], E | E2, R | R2>(
+          fromEffectOption<readonly [Chunk.Chunk<AL>, Chunk.Chunk<AR>, boolean], EL | ER, RL | RR>(
             Effect.raceWith(left, right, {
               onSelfDone: (leftDone, rightFiber) =>
                 pipe(
@@ -8020,23 +8020,23 @@ export const zipLatestWith = dual<
 )
 
 /** @internal */
-export const zipLeft = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<A, E2 | E, R2 | R>
->(
+export const zipLeft: {
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<AL, ER | EL, RR | RL>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AL, EL | ER, RL | RR>
+} = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<A, E | E2, R | R2> =>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AL, EL | ER, RL | RR> =>
     pipe(
-      self,
-      zipWithChunks(that, (left, right) => {
+      left,
+      zipWithChunks(right, (left, right) => {
         if (left.length > right.length) {
           return [
             pipe(left, Chunk.take(right.length)),
@@ -8052,23 +8052,23 @@ export const zipLeft = dual<
 )
 
 /** @internal */
-export const zipRight = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<A2, E2 | E, R2 | R>
->(
+export const zipRight: {
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<AR, ER | EL, RR | RL>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AR, EL | ER, RL | RR>
+} = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<A2, E | E2, R | R2> =>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AR, EL | ER, RL | RR> =>
     pipe(
-      self,
-      zipWithChunks(that, (left, right) => {
+      left,
+      zipWithChunks(right, (left, right) => {
         if (left.length > right.length) {
           return [
             right,
@@ -8084,24 +8084,24 @@ export const zipRight = dual<
 )
 
 /** @internal */
-export const zipWith = dual<
-  <A2, E2, R2, A, A3>(
-    that: Stream.Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A3, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2, A3>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ) => Stream.Stream<A3, E2 | E, R2 | R>
->(
+export const zipWith: {
+  <AR, ER, RR, AL, A>(
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): <EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<A, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream.Stream<A, EL | ER, RL | RR>
+} = dual(
   3,
-  <A, E, R, A2, E2, R2, A3>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ): Stream.Stream<A3, E2 | E, R2 | R> =>
-    pipe(self, zipWithChunks(that, (leftChunk, rightChunk) => zipChunks(leftChunk, rightChunk, f)))
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream.Stream<A, EL | ER, RL | RR> =>
+    pipe(left, zipWithChunks(right, (leftChunk, rightChunk) => zipChunks(leftChunk, rightChunk, f)))
 )
 
 /** @internal */

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.6.4"
+let moduleVersion = "3.6.6"
 
 export const getCurrentVersion = () => moduleVersion