effect 3.6.5 → 3.6.6

package/dist/cjs/internal/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.setCurrentVersion = exports.getCurrentVersion = void 0;
-let moduleVersion = "3.6.5";
+let moduleVersion = "3.6.6";
 const getCurrentVersion = () => moduleVersion;
 exports.getCurrentVersion = getCurrentVersion;
 const setCurrentVersion = version => {

package/dist/dts/Stream.d.ts

@@ -828,8 +828,8 @@ export declare const concat: {
 export declare const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>) => Stream<A, E, R>;
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements. The `that` stream would be run multiple times, for
- * every element in the `this` stream.
+ * product of elements. The `right` stream would be run multiple times, for
+ * every element in the `left` stream.
  *
  * See also `Stream.zip` for the more common point-wise variant.
  *
@@ -853,13 +853,13 @@ export declare const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>)
  * @category utils
  */
 export declare const cross: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<[AL, AR], EL | ER, RL | RR>;
+    <AL, ER, RR, AR, EL, RL>(left: Stream<AL, ER, RR>, right: Stream<AR, EL, RL>): Stream<[AL, AR], EL | ER, RL | RR>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements, but keeps only elements from this stream. The `that`
- * stream would be run multiple times, for every element in the `this` stream.
+ * product of elements, but keeps only elements from `left` stream. The `right`
+ * stream would be run multiple times, for every element in the `left` stream.
  *
  * See also `Stream.zipLeft` for the more common point-wise variant.
  *
@@ -867,13 +867,13 @@ export declare const cross: {
  * @category utils
  */
 export declare const crossLeft: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL, EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AL, EL | ER, RL | RR>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements, but keeps only elements from the other stream. The
- * `that` stream would be run multiple times, for every element in the `this`
+ * product of elements, but keeps only elements from the `right` stream. The
+ * `left` stream would be run multiple times, for every element in the `right`
  * stream.
  *
  * See also `Stream.zipRight` for the more common point-wise variant.
@@ -882,13 +882,13 @@ export declare const crossLeft: {
  * @category utils
  */
 export declare const crossRight: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AR, EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AR, EL | ER, RL | RR>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements with a specified function. The `that` stream would be
- * run multiple times, for every element in the `this` stream.
+ * product of elements with a specified function. The `right` stream would be
+ * run multiple times, for every element in the `left` stream.
  *
  * See also `Stream.zipWith` for the more common point-wise variant.
  *
@@ -896,8 +896,8 @@ export declare const crossRight: {
  * @category utils
  */
 export declare const crossWith: {
-    <B, E2, R2, A, C>(that: Stream<B, E2, R2>, f: (a: A, b: B) => C): <E, R>(self: Stream<A, E, R>) => Stream<C, E2 | E, R2 | R>;
-    <A, E, R, B, E2, R2, C>(self: Stream<A, E, R>, that: Stream<B, E2, R2>, f: (a: A, b: B) => C): Stream<C, E | E2, R | R2>;
+    <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): Stream<A, EL | ER, RL | RR>;
 };
 /**
  * Delays the emission of values by holding new values for a set duration. If
@@ -4570,8 +4570,8 @@ export declare const zipAllWith: {
  * @category zipping
  */
 export declare const zipLatest: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<[AL, AR], EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<[AL, AR], EL | ER, RL | RR>;
 };
 /**
  * Zips multiple streams so that when a value is emitted by any of the streams,
@@ -4625,12 +4625,12 @@ export declare const zipLatestAll: <T extends ReadonlyArray<Stream<any, any, any
  * @category zipping
  */
 export declare const zipLatestWith: {
-    <A2, E2, R2, A, A3>(that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): Stream<A3, E | E2, R | R2>;
+    <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): Stream<A, EL | ER, RL | RR>;
 };
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of
- * this stream.
+ * `left` stream.
  *
  * The new stream will end when one of the sides ends.
  *
@@ -4638,12 +4638,12 @@ export declare const zipLatestWith: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL, ER | EL, RR | RL>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AL, EL | ER, RL | RR>;
 };
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of the
- * other stream.
+ * `right` stream.
  *
  * The new stream will end when one of the sides ends.
  *
@@ -4651,8 +4651,8 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AR, ER | EL, RR | RL>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AR, EL | ER, RL | RR>;
 };
 /**
  * Zips this stream with another point-wise and applies the function to the
@@ -4677,8 +4677,8 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <A2, E2, R2, A, A3>(that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): Stream<A3, E | E2, R | R2>;
+    <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>;
+    <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): Stream<A, EL | ER, RL | RR>;
 };
 /**
  * Zips this stream with another point-wise and applies the function to the