effect 4.0.0-beta.5 → 4.0.0-beta.51

package/dist/Channel.js

@@ -60,14 +60,15 @@
 import * as Arr from "./Array.js";
 import * as Cause from "./Cause.js";
 import * as Chunk from "./Chunk.js";
+import * as Context from "./Context.js";
 import * as Effect from "./Effect.js";
 import * as Exit from "./Exit.js";
 import * as Fiber from "./Fiber.js";
-import * as Filter from "./Filter.js";
 import { constant, constTrue, constVoid, dual, identity as identity_ } from "./Function.js";
 import { ClockRef, endSpan } from "./internal/effect.js";
 import { addSpanStackTrace } from "./internal/tracer.js";
 import * as Iterable from "./Iterable.js";
+import * as Latch from "./Latch.js";
 import * as Layer from "./Layer.js";
 import * as Option from "./Option.js";
 import { pipeArguments } from "./Pipeable.js";
@@ -79,11 +80,15 @@ import { TracerTimingEnabled } from "./References.js";
 import * as Result from "./Result.js";
 import * as Schedule from "./Schedule.js";
 import * as Scope from "./Scope.js";
-import * as ServiceMap from "./ServiceMap.js";
+import * as Semaphore from "./Semaphore.js";
 import * as String from "./String.js";
 import * as Take from "./Take.js";
 import { ParentSpan } from "./Tracer.js";
-const TypeId = "~effect/Channel";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId = "~effect/Channel";
 /**
  * Tests if a value is a `Channel`.
  *
@@ -1376,10 +1381,10 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(Effect.fn
   const concurrencyN = options.concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : options.concurrency;
   const queue = yield* Queue.bounded(0);
   yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue));
-  const runFork = Effect.runForkWith(yield* Effect.services());
+  const runFork = Effect.runForkWith(yield* Effect.context());
   const trackFiber = Fiber.runIn(forkedScope);
   if (options.unordered) {
-    const semaphore = Effect.makeSemaphoreUnsafe(concurrencyN);
+    const semaphore = Semaphore.makeUnsafe(concurrencyN);
     const release = constant(semaphore.release(1));
     const handle = Effect.matchCauseEffect({
       onFailure: cause => Effect.flatMap(Queue.failCause(queue, cause), release),
@@ -1800,16 +1805,29 @@ export const schedule = /*#__PURE__*/dual(2, (self, schedule) => transformPull(s
  * @since 2.0.0
  * @category Filtering
  */
-export const filter = /*#__PURE__*/dual(2, (self, filter) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {
+export const filter = /*#__PURE__*/dual(2, (self, predicate) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {
+  return predicate(elem) ? Effect.succeed(elem) : Effect.flatMap(pull, loop);
+}))));
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap = /*#__PURE__*/dual(2, (self, filter) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {
   const result = filter(elem);
-  if (result === true) return Effect.succeed(elem);else if (result === false) return Effect.flatMap(pull, loop);else if (Result.isSuccess(result)) return Effect.succeed(result.success);
-  return Effect.flatMap(pull, loop);
+  return Result.isFailure(result) ? Effect.flatMap(pull, loop) : Effect.succeed(result.success);
+}))));
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterEffect = /*#__PURE__*/dual(2, (self, predicate) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {
+  return Effect.flatMap(predicate(elem), passes => passes ? Effect.succeed(elem) : Effect.flatMap(pull, loop));
 }))));
 /**
  * @since 4.0.0
  * @category Filtering
  */
-export const filterEffect = /*#__PURE__*/dual(2, (self, filter) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {
+export const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {
   return Effect.flatMap(filter(elem), result => Result.isFailure(result) ? Effect.flatMap(pull, loop) : Effect.succeed(result.success));
 }))));
 /**
@@ -1847,28 +1865,46 @@ export const filterEffect = /*#__PURE__*/dual(2, (self, filter) => fromTransform
  * @since 4.0.0
  * @category Filtering
  */
-export const filterArray = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {
-  const [, passes] = Arr.partition(arr, filter);
+export const filterArray = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {
+  const passes = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i])) {
+      passes.push(arr[i]);
+    }
+  }
   return Arr.isReadonlyArrayNonEmpty(passes) ? Effect.succeed(passes) : Effect.flatMap(pull, loop);
 }))));
 /**
  * @since 4.0.0
  * @category Filtering
  */
-export const filterArrayEffect = /*#__PURE__*/dual(2, (self, filter) => {
-  if (filter.length > 1) {
-    // effectful boolean predicate: (a, index) => Effect<boolean>
-    const predicate = filter;
-    return transformPull(self, pull => {
-      const f = Effect.flatMap(pull, arr => Effect.filter(arr, predicate));
-      return Effect.succeed(Effect.flatMap(f, function loop(arr) {
-        return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop);
-      }));
-    });
+export const filterMapArray = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {
+  const passes = [];
+  for (let i = 0; i < arr.length; i++) {
+    const result = filter(arr[i]);
+    if (Result.isSuccess(result)) {
+      passes.push(result.success);
+    }
   }
-  // FilterEffect: (a) => Effect<pass|fail>
-  return filterEffect(self, arr => Effect.map(Effect.filter(arr, filter), passes => Arr.isReadonlyArrayNonEmpty(passes) ? Result.succeed(passes) : Result.fail(undefined)));
-});
+  return Arr.isReadonlyArrayNonEmpty(passes) ? Effect.succeed(passes) : Effect.flatMap(pull, loop);
+}))));
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterArrayEffect = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, pull => {
+  const f = Effect.flatMap(pull, arr => Effect.filter(arr, predicate));
+  return Effect.succeed(Effect.flatMap(f, function loop(arr) {
+    return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop);
+  }));
+}));
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapArrayEffect = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {
+  return Effect.flatMap(Effect.filterMapEffect(arr, filter), passes => Arr.isReadonlyArrayNonEmpty(passes) ? Effect.succeed(passes) : Effect.flatMap(pull, loop));
+}))));
 /**
  * Statefully maps over a channel with an accumulator, where each element can produce multiple output values.
  *
@@ -2022,13 +2058,15 @@ export const scan = /*#__PURE__*/dual(3, (self, initial, f) => scanEffect(self,
 export const scanEffect = /*#__PURE__*/dual(3, (self, initial, f) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => {
   let state = initial;
   let isFirst = true;
-  if (isFirst) {
-    isFirst = false;
-    return Effect.succeed(state);
-  }
-  return Effect.map(Effect.flatMap(pull, a => f(state, a)), newState => {
-    state = newState;
-    return state;
+  return Effect.suspend(() => {
+    if (isFirst) {
+      isFirst = false;
+      return Effect.succeed(state);
+    }
+    return Effect.map(Effect.flatMap(pull, a => f(state, a)), newState => {
+      state = newState;
+      return state;
+    });
   });
 })));
 /**
@@ -2095,12 +2133,18 @@ export const tapCause = /*#__PURE__*/dual(2, (self, f) => catchCause(self, cause
  * @since 4.0.0
  * @category Error handling
  */
-export const catchCauseIf = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {
-  const eb = filter(cause);
-  if (eb === true) return f(cause, cause);else if (eb === false) return failCause(cause);else if (Result.isSuccess(eb)) return f(eb.success, cause);
-  return failCause(eb.failure);
+export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCause(self, cause => {
+  return predicate(cause) ? f(cause) : failCause(cause);
 }));
-const catch_ = /*#__PURE__*/dual(2, (self, f) => catchCauseIf(self, Cause.findError, e => f(e)));
+/**
+ * @since 4.0.0
+ * @category Error handling
+ */
+export const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {
+  const result = filter(cause);
+  return Result.isFailure(result) ? failCause(result.failure) : f(result.success, cause);
+}));
+const catch_ = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, Cause.findError, e => f(e)));
 export {
 /**
  * @since 4.0.0
@@ -2116,9 +2160,16 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => transformPull(self, pu
  * @since 4.0.0
  * @category Error handling
  */
-export const catchIf = /*#__PURE__*/dual(args => isChannel(args[0]), (self, filter, f, orElse) => catch_(self, err => {
-  const eb = Filter.apply(filter, err);
-  return !Result.isFailure(eb) ? f(eb.success) : orElse ? orElse(eb.failure) : fail(eb.failure);
+export const catchIf = /*#__PURE__*/dual(args => isChannel(args[0]), (self, predicate, f, orElse) => catch_(self, err => {
+  return predicate(err) ? f(err) : orElse ? orElse(err) : fail(err);
+}));
+/**
+ * @since 4.0.0
+ * @category Error handling
+ */
+export const catchFilter = /*#__PURE__*/dual(args => isChannel(args[0]), (self, filter, f, orElse) => catch_(self, err => {
+  const result = filter(err);
+  return Result.isFailure(result) ? orElse ? orElse(result.failure) : fail(result.failure) : f(result.success);
 }));
 /**
  * @since 4.0.0
@@ -2165,9 +2216,9 @@ export const catchReason = /*#__PURE__*/dual(args => isChannel(args[0]), (self,
   if (isTagged(error, errorTag) && hasProperty(error, "reason")) {
     const reason = error.reason;
     if (isTagged(reason, reasonTag)) {
-      return f(reason);
+      return f(reason, error);
     }
-    return orElse ? orElse(reason) : fail(error);
+    return orElse ? orElse(reason, error) : fail(error);
   }
   return fail(error);
 }));
@@ -2184,9 +2235,9 @@ export const catchReasons = /*#__PURE__*/dual(args => isChannel(args[0]), (self,
       const reason = error.reason;
       keys ??= new Set(Object.keys(cases));
       if (keys.has(reason._tag)) {
-        return cases[reason._tag](reason);
+        return cases[reason._tag](reason, error);
       }
-      return orElse ? orElse(reason) : fail(error);
+      return orElse ? orElse(reason, error) : fail(error);
     }
     return fail(error);
   });
@@ -2220,7 +2271,7 @@ export const catchReasons = /*#__PURE__*/dual(args => isChannel(args[0]), (self,
  * @since 4.0.0
  * @category Error handling
  */
-export const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchIf(self, error => isTagged(error, errorTag) && hasProperty(error, "reason") ? Result.succeed(error.reason) : Result.fail(error), fail));
+export const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchFilter(self, error => isTagged(error, errorTag) && hasProperty(error, "reason") ? Result.succeed(error.reason) : Result.fail(error), fail));
 /**
  * Returns a new channel, which is the same as this one, except the failure
  * value of the returned channel is created by applying the specified function
@@ -2380,8 +2431,8 @@ export const mergeAll = /*#__PURE__*/dual(2, (channels, {
   switch: switch_ = false
 }) => fromTransformBracket(Effect.fnUntraced(function* (upstream, scope, forkedScope) {
   const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.max(1, concurrency);
-  const semaphore = switch_ ? undefined : Effect.makeSemaphoreUnsafe(concurrencyN);
-  const doneLatch = yield* Effect.makeLatch(true);
+  const semaphore = switch_ ? undefined : Semaphore.makeUnsafe(concurrencyN);
+  const doneLatch = yield* Latch.make(true);
   const fibers = new Set();
   const queue = yield* Queue.bounded(bufferSize);
   yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue));
@@ -2483,14 +2534,54 @@ export const mergeEffect = /*#__PURE__*/dual(2, (self, effect) => merge(self, fr
   haltStrategy: "left"
 }));
 /**
+ * Splits upstream string chunks into lines, recognizing `\n`, `\r\n`, and
+ * standalone `\r` as line terminators. The behavior matches
+ * `String.linesIterator` regardless of how the input is chunked.
+ *
+ * A line terminator at the very end of the stream does **not** produce a
+ * trailing empty line (consistent with `String.linesIterator`). Conversely,
+ * if the stream ends without a terminator the final partial line is still
+ * emitted.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Stream } from "effect"
+ *
+ * Effect.runPromise(Effect.gen(function*() {
+ *   const result = yield* Stream.runCollect(
+ *     Stream.splitLines(Stream.make("hel", "lo\r\nwor", "ld\n"))
+ *   )
+ *   console.log(result)
+ *   // [ 'hello', 'world' ]
+ * }))
+ * ```
+ *
  * @since 2.0.0
  * @category String manipulation
  */
 export const splitLines = () => fromTransform((upstream, _scope) => Effect.sync(() => {
+  // Accumulates text that has not yet been terminated by a line break.
+  // Content is carried across chunks until a terminator is found.
   let stringBuilder = "";
+  // Set when a chunk ends with \r so the next chunk can check whether
+  // the following character is \n (completing a \r\n pair) or not
+  // (standalone \r, which is itself a line terminator).
   let midCRLF = false;
-  const splitLinesArray = chunk => {
+  // Remembers the upstream Done value after the first time the upstream
+  // signals completion, so subsequent pulls return Done immediately
+  // without pulling upstream again.
+  let done = Option.none();
+  function splitLinesArray(chunk) {
     const chunkBuilder = [];
+    function pushLine(segment) {
+      if (stringBuilder.length === 0) {
+        chunkBuilder.push(segment);
+      } else {
+        chunkBuilder.push(stringBuilder + segment);
+        stringBuilder = "";
+      }
+    }
     for (let i = 0; i < chunk.length; i++) {
       const str = chunk[i];
       if (str.length !== 0) {
@@ -2499,23 +2590,17 @@ export const splitLines = () => fromTransform((upstream, _scope) => Effect.sync(
         let indexOfLF = str.indexOf("\n");
         if (midCRLF) {
           if (indexOfLF === 0) {
-            chunkBuilder.push(stringBuilder);
-            stringBuilder = "";
+            pushLine("");
             from = 1;
             indexOfLF = str.indexOf("\n", from);
           } else {
-            stringBuilder = stringBuilder + "\r";
+            pushLine("");
           }
           midCRLF = false;
         }
         while (indexOfCR !== -1 || indexOfLF !== -1) {
           if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {
-            if (stringBuilder.length === 0) {
-              chunkBuilder.push(str.substring(from, indexOfLF));
-            } else {
-              chunkBuilder.push(stringBuilder + str.substring(from, indexOfLF));
-              stringBuilder = "";
-            }
+            pushLine(str.substring(from, indexOfLF));
             from = indexOfLF + 1;
             indexOfLF = str.indexOf("\n", from);
           } else {
@@ -2523,36 +2608,42 @@ export const splitLines = () => fromTransform((upstream, _scope) => Effect.sync(
               midCRLF = true;
               indexOfCR = -1;
             } else {
-              if (indexOfLF === indexOfCR + 1) {
-                if (stringBuilder.length === 0) {
-                  chunkBuilder.push(str.substring(from, indexOfCR));
-                } else {
-                  stringBuilder = stringBuilder + str.substring(from, indexOfCR);
-                  chunkBuilder.push(stringBuilder);
-                  stringBuilder = "";
-                }
-                from = indexOfCR + 2;
-                indexOfCR = str.indexOf("\r", from);
-                indexOfLF = str.indexOf("\n", from);
-              } else {
-                indexOfCR = str.indexOf("\r", indexOfCR + 1);
-              }
+              pushLine(str.substring(from, indexOfCR));
+              from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1);
+              indexOfCR = str.indexOf("\r", from);
+              indexOfLF = str.indexOf("\n", from);
             }
           }
         }
-        if (midCRLF) {
-          stringBuilder = stringBuilder + str.substring(from, str.length - 1);
-        } else {
-          stringBuilder = stringBuilder + str.substring(from, str.length);
-        }
+        stringBuilder = stringBuilder + str.substring(from, str.length - (midCRLF ? 1 : 0));
       }
     }
     return Arr.isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null;
-  };
-  return Effect.flatMap(upstream, function loop(chunk) {
-    const lines = splitLinesArray(chunk);
-    return lines !== null ? Effect.succeed(lines) : Effect.flatMap(upstream, loop);
+  }
+  const pullOrFlush = Effect.suspend(() => {
+    if (done._tag === "Some") {
+      return Cause.done(done.value);
+    }
+    return Pull.matchEffect(upstream, {
+      onSuccess: loop,
+      onFailure: Effect.failCause,
+      onDone: leftover => {
+        done = Option.some(leftover);
+        if (stringBuilder.length > 0 || midCRLF) {
+          const last = stringBuilder;
+          stringBuilder = "";
+          midCRLF = false;
+          return Effect.succeed([last]);
+        }
+        return Cause.done(leftover);
+      }
+    });
   });
+  function loop(chunk) {
+    const lines = splitLinesArray(chunk);
+    return lines !== null ? Effect.succeed(lines) : pullOrFlush;
+  }
+  return pullOrFlush;
 }));
 /**
  * @since 4.0.0
@@ -2852,16 +2943,16 @@ const runWith = (self, f, onHalt) => Effect.suspend(() => {
  * @since 2.0.0
  * @category Services
  */
-export const servicesWith = f => fromTransform((upstream, scope) => Effect.servicesWith(services => toTransform(f(services))(upstream, scope)));
+export const contextWith = f => fromTransform((upstream, scope) => Effect.contextWith(context => toTransform(f(context))(upstream, scope)));
 /**
- * Provides a layer or service map to the channel, removing the corresponding
+ * Provides a layer or context to the channel, removing the corresponding
  * service requirements. Use `options.local` to build the layer every time; by
  * default, layers are shared between provide calls.
  *
  * @since 4.0.0
  * @category Services
  */
-export const provideServices = /*#__PURE__*/dual(2, (self, services) => fromTransform((upstream, scope) => Effect.map(Effect.provideServices(toTransform(self)(upstream, scope), services), Effect.provideServices(services))));
+export const provideContext = /*#__PURE__*/dual(2, (self, context) => fromTransform((upstream, scope) => Effect.map(Effect.provideContext(toTransform(self)(upstream, scope), context), Effect.provideContext(context))));
 /**
  * @since 4.0.0
  * @category Services
@@ -2876,20 +2967,20 @@ export const provideServiceEffect = /*#__PURE__*/dual(3, (self, key, service) =>
  * @since 4.0.0
  * @category Services
  */
-export const provide = /*#__PURE__*/dual(args => isChannel(args[0]), (self, layer, options) => ServiceMap.isServiceMap(layer) ? provideServices(self, layer) : fromTransform((upstream, scope) => Effect.flatMap(options?.local ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope) : Layer.buildWithScope(layer, scope), services => Effect.map(Effect.provideServices(toTransform(self)(upstream, scope), services), Effect.provideServices(services)))));
+export const provide = /*#__PURE__*/dual(args => isChannel(args[0]), (self, layer, options) => Context.isContext(layer) ? provideContext(self, layer) : fromTransform((upstream, scope) => Effect.flatMap(options?.local ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope) : Layer.buildWithScope(layer, scope), context => Effect.map(Effect.provideContext(toTransform(self)(upstream, scope), context), Effect.provideContext(context)))));
 /**
  * @since 2.0.0
  * @category Services
  */
-export const updateServices = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => Effect.servicesWith(services => {
-  const toProvide = f(services);
-  return toTransform(provideServices(self, toProvide))(upstream, scope);
+export const updateContext = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => Effect.contextWith(context => {
+  const toProvide = f(context);
+  return toTransform(provideContext(self, toProvide))(upstream, scope);
 })));
 /**
  * @since 2.0.0
  * @category Services
  */
-export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateServices(self, services => ServiceMap.add(services, service, f(ServiceMap.get(services, service)))));
+export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateContext(self, context => Context.add(context, service, f(Context.get(context, service)))));
 /**
  * @since 4.0.0
  * @category Tracing
@@ -3161,11 +3252,11 @@ export const runFoldEffect = /*#__PURE__*/dual(3, (self, initial, f) => Effect.s
  * @category Destructors
  */
 export const toPull = /*#__PURE__*/Effect.fnUntraced(function* (self) {
-  const semaphore = Effect.makeSemaphoreUnsafe(1);
-  const context = yield* Effect.services();
-  const scope = ServiceMap.get(context, Scope.Scope);
+  const semaphore = Semaphore.makeUnsafe(1);
+  const context = yield* Effect.context();
+  const scope = Context.get(context, Scope.Scope);
   const pull = yield* toTransform(self)(Cause.done(), scope);
-  return pull.pipe(Effect.provideServices(context), semaphore.withPermits(1));
+  return pull.pipe(Effect.provideContext(context), semaphore.withPermits(1));
 },
 /*#__PURE__*/
 // ensure errors are redirected to the pull effect