effect 3.10.16 → 3.10.17

package/src/Function.ts

@@ -516,22 +516,66 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
 /**
  * Pipes the value of an expression into a pipeline of functions.
  *
- * This is useful in combination with data-last functions as a simulation of methods:
+ * **When to Use**
  *
+ * This is useful in combination with data-last functions as a simulation of
+ * methods:
+ *
+ * ```ts
+ * as.map(f).filter(g)
+ * ```
+ *
+ * becomes:
+ *
+ * ```ts
+ * import { pipe, Array } from "effect"
+ *
+ * pipe(as, Array.map(f), Array.filter(g))
+ * ```
+ *
+ * **Details**
+ *
+ * The `pipe` function is a utility that allows us to compose functions in a
+ * readable and sequential manner. It takes the output of one function and
+ * passes it as the input to the next function in the pipeline. This enables us
+ * to build complex transformations by chaining multiple functions together.
+ *
+ * ```ts
+ * import { pipe } from "effect"
+ *
+ * const result = pipe(input, func1, func2, ..., funcN)
  * ```
- * as.map(f).filter(g) -> pipe(as, map(f), filter(g))
+ *
+ * In this syntax, `input` is the initial value, and `func1`, `func2`, ...,
+ * `funcN` are the functions to be applied in sequence. The result of each
+ * function becomes the input for the next function, and the final result is
+ * returned.
+ *
+ * Here's an illustration of how `pipe` works:
+ *
+ * ```text
+ * ┌───────┐    ┌───────┐    ┌───────┐    ┌───────┐    ┌───────┐    ┌────────┐
+ * │ input │───►│ func1 │───►│ func2 │───►│  ...  │───►│ funcN │───►│ result │
+ * └───────┘    └───────┘    └───────┘    └───────┘    └───────┘    └────────┘
  * ```
  *
+ * It's important to note that functions passed to `pipe` must have a **single
+ * argument** because they are only called with a single argument.
+ *
  * @example
- * import { pipe } from "effect/Function"
- * // Alternatively, you can use the following import syntax, as `pipe` is also conveniently exported from the `effect` entry point:
- * // import { pipe } from "effect"
+ * // Example: Chaining Arithmetic Operations
+ * import { pipe } from "effect"
  *
- * const length = (s: string): number => s.length
- * const double = (n: number): number => n * 2
- * const decrement = (n: number): number => n - 1
+ * // Define simple arithmetic operations
+ * const increment = (x: number) => x + 1
+ * const double = (x: number) => x * 2
+ * const subtractTen = (x: number) => x - 10
+ *
+ * // Sequentially apply these operations using `pipe`
+ * const result = pipe(5, increment, double, subtractTen)
  *
- * assert.deepStrictEqual(pipe(length("hello"), double, decrement), 9)
+ * console.log(result)
+ * // Output: 2
  *
  * @since 2.0.0
  */

package/src/Layer.ts

@@ -368,7 +368,7 @@ export const effect: {
 } = internal.fromEffect
 
 /**
- * Constructs a layer from the specified effect discarding it's output.
+ * Constructs a layer from the specified effect, discarding its output.
  *
  * @since 2.0.0
  * @category constructors

package/src/internal/core-effect.ts

@@ -1028,23 +1028,23 @@ const loopDiscard = <S, X, E, R>(
 /* @internal */
 export const mapAccum: {
   <S, A, B, E, R, I extends Iterable<A> = Iterable<A>>(
-    zero: S,
-    f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
+    initial: S,
+    f: (state: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
   ): (elements: I) => Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
   <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
     elements: I,
-    zero: S,
-    f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
+    initial: S,
+    f: (state: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
   ): Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
 } = dual(3, <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
   elements: I,
-  zero: S,
-  f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
+  initial: S,
+  f: (state: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
 ): Effect.Effect<[S, Array<B>], E, R> =>
   core.suspend(() => {
     const iterator = elements[Symbol.iterator]()
     const builder: Array<B> = []
-    let result: Effect.Effect<S, E, R> = core.succeed(zero)
+    let result: Effect.Effect<S, E, R> = core.succeed(initial)
     let next: IteratorResult<A, any>
     let i = 0
     while (!(next = iterator.next()).done) {

package/src/internal/fiberRuntime.ts

@@ -812,6 +812,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     for (let i = this._observers.length - 1; i >= 0; i--) {
       this._observers[i](exit)
     }
+    this._observers = []
   }
 
   getLoggers() {

package/src/internal/version.ts

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