effect 2.4.5 → 2.4.6

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "2.4.5";
+let moduleVersion = "2.4.6";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.4.5",
+  "version": "2.4.6",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Channel.ts

@@ -1951,6 +1951,23 @@ export const scoped: <A, E, R>(
   effect: Effect.Effect<A, E, R>
 ) => Channel<A, unknown, E, unknown, unknown, unknown, Exclude<R, Scope.Scope>> = channel.scoped
 
+/**
+ * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
+ * newlines (`\n`).
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export const splitLines: <Err, Done>() => Channel<
+  Chunk.Chunk<string>,
+  Chunk.Chunk<string>,
+  Err,
+  Err,
+  Done,
+  Done,
+  never
+> = channel.splitLines
+
 /**
  * Constructs a channel that succeeds immediately with the specified value.
  *

package/src/Effect.ts

@@ -18,6 +18,7 @@ import type * as FiberId from "./FiberId.js"
 import type * as FiberRef from "./FiberRef.js"
 import type * as FiberRefs from "./FiberRefs.js"
 import type * as FiberRefsPatch from "./FiberRefsPatch.js"
+import type * as FiberStatus from "./FiberStatus.js"
 import type { LazyArg } from "./Function.js"
 import { dual } from "./Function.js"
 import type * as HashMap from "./HashMap.js"
@@ -129,8 +130,8 @@ export interface EffectTypeLambda extends TypeLambda {
  */
 export interface Blocked<out A, out E> extends Effect<A, E> {
   readonly _op: "Blocked"
-  readonly i0: RequestBlock
-  readonly i1: Effect<A, E>
+  readonly effect_instruction_i0: RequestBlock
+  readonly effect_instruction_i1: Effect<A, E>
 }
 
 /**
@@ -994,6 +995,48 @@ export const asyncEffect: <A, E, R, R3, E2, R2>(
   register: (callback: (_: Effect<A, E, R>) => void) => Effect<Effect<void, never, R3> | void, E2, R2>
 ) => Effect<A, E | E2, R | R2 | R3> = _runtime.asyncEffect
 
+/**
+ * Low level constructor that enables for custom stack tracing cutpoints.
+ *
+ * It is meant to be called with a bag of instructions that become available in the "this" of the effect.
+ *
+ * @example
+ * import * as Effect from "effect/Effect"
+ *
+ * const throwingFunction = () => { throw new Error() }
+ * const blowUp = Effect.custom(throwingFunction, function() {
+ *   return Effect.succeed(this.effect_instruction_i0())
+ * })
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const custom: {
+  <X, A, E, R>(i0: X, body: (this: { effect_instruction_i0: X }) => Effect<A, E, R>): Effect<A, E, R>
+  <X, Y, A, E, R>(
+    i0: X,
+    i1: Y,
+    body: (this: { effect_instruction_i0: X; effect_instruction_i1: Y }) => Effect<A, E, R>
+  ): Effect<A, E, R>
+  <X, Y, Z, A, E, R>(
+    i0: X,
+    i1: Y,
+    i2: Z,
+    body: (this: { effect_instruction_i0: X; effect_instruction_i1: Y; effect_instruction_i2: Z }) => Effect<A, E, R>
+  ): Effect<A, E, R>
+} = core.custom
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const withFiberRuntime: <A, E = never, R = never>(
+  withRuntime: (
+    fiber: Fiber.RuntimeFiber<A, E>,
+    status: FiberStatus.Running
+  ) => Effect<A, E, R>
+) => Effect<A, E, R> = core.withFiberRuntime
+
 /**
  * @since 2.0.0
  * @category constructors

package/src/Exit.ts

@@ -40,7 +40,7 @@ export interface Failure<out A, out E> extends Effect.Effect<A, E>, Pipeable, In
   [Unify.unifySymbol]?: ExitUnify<this>
   [Unify.ignoreSymbol]?: ExitUnifyIgnore
   /** @internal */
-  readonly i0: Cause.Cause<E>
+  readonly effect_instruction_i0: Cause.Cause<E>
 }
 
 /**
@@ -74,7 +74,7 @@ export interface Success<out A, out E> extends Effect.Effect<A, E>, Pipeable, In
   [Unify.unifySymbol]?: ExitUnify<this>
   [Unify.ignoreSymbol]?: ExitUnifyIgnore
   /** @internal */
-  readonly i0: A
+  readonly effect_instruction_i0: A
 }
 
 /**

package/src/internal/cause.ts

@@ -971,8 +971,8 @@ const filterStack = (stack: string) => {
   const lines = stack.split("\n")
   const out: Array<string> = []
   for (let i = 0; i < lines.length; i++) {
-    out.push(lines[i].replace(/at .*effect_cutpoint.*\((.*)\)/, "at $1"))
-    if (lines[i].includes("effect_cutpoint")) {
+    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1"))
+    if (lines[i].includes("effect_instruction_i")) {
       return out.join("\n")
     }
   }

package/src/internal/channel.ts

@@ -2105,6 +2105,98 @@ export const serviceWithEffect = <T extends Context.Tag<any, any>>(tag: T) =>
 ): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | Context.Tag.Identifier<T>> =>
   mapEffect(service(tag), f)
 
+/** @internal */
+export const splitLines = <Err, Done>(): Channel.Channel<
+  Chunk.Chunk<string>,
+  Chunk.Chunk<string>,
+  Err,
+  Err,
+  Done,
+  Done,
+  never
+> =>
+  core.suspend(() => {
+    let stringBuilder = ""
+    let midCRLF = false
+    const splitLinesChunk = (chunk: Chunk.Chunk<string>): Chunk.Chunk<string> => {
+      const chunkBuilder: Array<string> = []
+      Chunk.map(chunk, (str) => {
+        if (str.length !== 0) {
+          let from = 0
+          let indexOfCR = str.indexOf("\r")
+          let indexOfLF = str.indexOf("\n")
+          if (midCRLF) {
+            if (indexOfLF === 0) {
+              chunkBuilder.push(stringBuilder)
+              stringBuilder = ""
+              from = 1
+              indexOfLF = str.indexOf("\n", from)
+            } else {
+              stringBuilder = stringBuilder + "\r"
+            }
+            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 = ""
+              }
+              from = indexOfLF + 1
+              indexOfLF = str.indexOf("\n", from)
+            } else {
+              if (str.length === indexOfCR + 1) {
+                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)
+                }
+              }
+            }
+          }
+          if (midCRLF) {
+            stringBuilder = stringBuilder + str.substring(from, str.length - 1)
+          } else {
+            stringBuilder = stringBuilder + str.substring(from, str.length)
+          }
+        }
+      })
+      return Chunk.unsafeFromArray(chunkBuilder)
+    }
+    const loop: Channel.Channel<Chunk.Chunk<string>, Chunk.Chunk<string>, Err, Err, Done, Done, never> = core
+      .readWithCause({
+        onInput: (input: Chunk.Chunk<string>) => {
+          const out = splitLinesChunk(input)
+          return Chunk.isEmpty(out)
+            ? loop
+            : core.flatMap(core.write(out), () => loop)
+        },
+        onFailure: (cause) =>
+          stringBuilder.length === 0
+            ? core.failCause(cause)
+            : core.flatMap(core.write(Chunk.of(stringBuilder)), () => core.failCause(cause)),
+        onDone: (done) =>
+          stringBuilder.length === 0
+            ? core.succeed(done)
+            : core.flatMap(core.write(Chunk.of(stringBuilder)), () => core.succeed(done))
+      })
+    return loop
+  })
+
 /** @internal */
 export const toPubSub = <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>

package/src/internal/core-effect.ts

@@ -30,7 +30,6 @@ import * as internalCause from "./cause.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import * as fiberRefsPatch from "./fiberRefs/patch.js"
-import { internalize } from "./internalize.js"
 import * as metricLabel from "./metric/label.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as SingleShotGen from "./singleShotGen.js"
@@ -778,7 +777,6 @@ export const gen: typeof Effect.gen = function() {
   } else {
     f = arguments[1].bind(arguments[0])
   }
-  internalize(f)
   return core.suspend(() => {
     const iterator = f(adapter)
     const state = iterator.next()