effect 2.4.19 → 3.0.0

package/src/internal/core.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Context from "../Context.js"
@@ -27,7 +28,6 @@ import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, isObject, isPromiseLike, isString, type Predicate, type Refinement } from "../Predicate.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as BlockedRequests from "../RequestBlock.js"
 import type * as RequestResolver from "../RequestResolver.js"
@@ -35,7 +35,7 @@ import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
-import type { NoInfer, NotFunction } from "../Types.js"
+import type { NotFunction } from "../Types.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
@@ -430,7 +430,7 @@ export const as: {
 )
 
 /* @internal */
-export const asUnit = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> => as(self, void 0)
+export const asVoid = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> => as(self, void 0)
 
 /* @internal */
 export const custom: {
@@ -515,7 +515,7 @@ export const async = <A, E = never, R = never>(
         if (controllerRef) {
           controllerRef.abort()
         }
-        return cancelerRef ?? unit
+        return cancelerRef ?? void_
       }) :
       effect
   })
@@ -886,8 +886,8 @@ export const forEachSequential: {
   2,
   <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect.Effect<B, E, R>): Effect.Effect<Array<B>, E, R> =>
     suspend(() => {
-      const arr = ReadonlyArray.fromIterable(self)
-      const ret = new Array(arr.length)
+      const arr = Array.fromIterable(self)
+      const ret = Array.allocate<B>(arr.length)
       let i = 0
       return as(
         whileLoop({
@@ -897,7 +897,7 @@ export const forEachSequential: {
             ret[i++] = b
           }
         }),
-        ret
+        ret as Array<B>
       )
     })
 )
@@ -910,7 +910,7 @@ export const forEachSequentialDiscard: {
   2,
   <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect.Effect<B, E, R>): Effect.Effect<void, E, R> =>
     suspend(() => {
-      const arr = ReadonlyArray.fromIterable(self)
+      const arr = Array.fromIterable(self)
       let i = 0
       return whileLoop({
         while: () => i < arr.length,
@@ -926,35 +926,33 @@ export const forEachSequentialDiscard: {
 export const if_ = dual<
   <A1, E1, R1, A2, E2, R2>(
     options: {
-      readonly onTrue: Effect.Effect<A1, E1, R1>
-      readonly onFalse: Effect.Effect<A2, E2, R2>
+      readonly onTrue: LazyArg<Effect.Effect<A1, E1, R1>>
+      readonly onFalse: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ) => <E = never, R = never>(
     self: Effect.Effect<boolean, E, R> | boolean
   ) => Effect.Effect<A1 | A2, E | E1 | E2, R | R1 | R2>,
-  {
-    <A1, E1, R1, A2, E2, R2>(
-      self: boolean,
-      options: {
-        readonly onTrue: Effect.Effect<A1, E1, R1>
-        readonly onFalse: Effect.Effect<A2, E2, R2>
-      }
-    ): Effect.Effect<A1 | A2, E1 | E2, R1 | R2>
-    <E, R, A1, E1, R1, A2, E2, R2>(
-      self: Effect.Effect<boolean, E, R>,
-      options: {
-        readonly onTrue: Effect.Effect<A1, E1, R1>
-        readonly onFalse: Effect.Effect<A2, E2, R2>
-      }
-    ): Effect.Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
-  }
+  <A1, E1, R1, A2, E2, R2, E = never, R = never>(
+    self: Effect.Effect<boolean, E, R> | boolean,
+    options: {
+      readonly onTrue: LazyArg<Effect.Effect<A1, E1, R1>>
+      readonly onFalse: LazyArg<Effect.Effect<A2, E2, R2>>
+    }
+  ) => Effect.Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
 >(
   (args) => typeof args[0] === "boolean" || isEffect(args[0]),
-  (self: boolean | Effect.Effect<unknown, unknown, unknown>, { onFalse, onTrue }: {
-    readonly onTrue: Effect.Effect<unknown, unknown, unknown>
-    readonly onFalse: Effect.Effect<unknown, unknown, unknown>
-    // eslint-disable-next-line no-extra-boolean-cast
-  }) => isEffect(self) ? flatMap(self, (b) => (b ? onTrue : onFalse)) : Boolean(self) ? onTrue : onFalse
+  <A1, E1, R1, A2, E2, R2, E = never, R = never>(
+    self: Effect.Effect<boolean, E, R> | boolean,
+    options: {
+      readonly onTrue: LazyArg<Effect.Effect<A1, E1, R1>>
+      readonly onFalse: LazyArg<Effect.Effect<A2, E2, R2>>
+    }
+  ): Effect.Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R> =>
+    isEffect(self)
+      ? flatMap(self, (b): Effect.Effect<A1 | A2, E1 | E2, R1 | R2> => (b ? options.onTrue() : options.onFalse()))
+      : self
+      ? options.onTrue()
+      : options.onFalse()
 )
 
 /* @internal */
@@ -1065,7 +1063,7 @@ export const onError: {
   self: Effect.Effect<A, E, R>,
   cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>
 ): Effect.Effect<A, E, R2 | R> =>
-  onExit(self, (exit) => exitIsSuccess(exit) ? unit : cleanup(exit.effect_instruction_i0)))
+  onExit(self, (exit) => exitIsSuccess(exit) ? void_ : cleanup(exit.effect_instruction_i0)))
 
 /* @internal */
 export const onExit: {
@@ -1114,9 +1112,9 @@ export const onInterrupt: {
     exitMatch({
       onFailure: (cause) =>
         internalCause.isInterruptedOnly(cause)
-          ? asUnit(cleanup(internalCause.interruptors(cause)))
-          : unit,
-      onSuccess: () => unit
+          ? asVoid(cleanup(internalCause.interruptors(cause)))
+          : void_,
+      onSuccess: () => void_
     })
   ))
 
@@ -1158,7 +1156,7 @@ export const partitionMap = <A, A1, A2>(
   elements: Iterable<A>,
   f: (a: A) => Either.Either<A2, A1>
 ): [left: Array<A1>, right: Array<A2>] =>
-  ReadonlyArray.fromIterable(elements).reduceRight(
+  Array.fromIterable(elements).reduceRight(
     ([lefts, rights], current) => {
       const either = f(current)
       switch (either._tag) {
@@ -1170,7 +1168,7 @@ export const partitionMap = <A, A1, A2>(
         }
       }
     },
-    [new Array<A1>(), new Array<A2>()]
+    [Array.empty<A1>(), Array.empty<A2>()]
   )
 
 /* @internal */
@@ -1302,8 +1300,11 @@ export const uninterruptibleMask = <A, E, R>(
     return effect
   })
 
-/* @internal */
-export const unit: Effect.Effect<void> = succeed(void 0)
+const void_: Effect.Effect<void> = succeed(void 0)
+export {
+  /* @internal */
+  void_ as void
+}
 
 /* @internal */
 export const updateRuntimeFlags = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): Effect.Effect<void> => {
@@ -1668,7 +1669,7 @@ export const fiberRefSet = dual<
 export const fiberRefDelete = <A>(self: FiberRef.FiberRef<A>): Effect.Effect<void> =>
   withFiberRuntime((state) => {
     state.unsafeDeleteFiberRef(self)
-    return unit
+    return void_
   })
 
 /* @internal */
@@ -1999,7 +2000,7 @@ export const withUnhandledErrorLogLevel = dual<
 /** @internal */
 export const currentMetricLabels: FiberRef.FiberRef<ReadonlyArray<MetricLabel.MetricLabel>> = globalValue(
   Symbol.for("effect/FiberRef/currentMetricLabels"),
-  () => fiberRefUnsafeMakeReadonlyArray(ReadonlyArray.empty())
+  () => fiberRefUnsafeMakeReadonlyArray(Array.empty())
 )
 
 /* @internal */
@@ -2067,7 +2068,7 @@ export const CloseableScopeTypeId: Scope.CloseableScopeTypeId = Symbol.for(
 export const scopeAddFinalizer = (
   self: Scope.Scope,
   finalizer: Effect.Effect<unknown>
-): Effect.Effect<void> => self.addFinalizer(() => asUnit(finalizer))
+): Effect.Effect<void> => self.addFinalizer(() => asVoid(finalizer))
 
 /* @internal */
 export const scopeAddFinalizerExit = (
@@ -2109,8 +2110,8 @@ export const causeSquashWith = dual<
         Chunk.head,
         Option.match({
           onNone: () => {
-            const interrupts = Array.from(internalCause.interruptors(self)).flatMap((fiberId) =>
-              Array.from(FiberId.ids(fiberId)).map((id) => `#${id}`)
+            const interrupts = Array.fromIterable(internalCause.interruptors(self)).flatMap((fiberId) =>
+              Array.fromIterable(FiberId.ids(fiberId)).map((id) => `#${id}`)
             )
             return new InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0)
           },
@@ -2310,7 +2311,7 @@ export const exitAs = dual<
 })
 
 /** @internal */
-export const exitAsUnit = <A, E>(self: Exit.Exit<A, E>): Exit.Exit<void, E> => exitAs(self, void 0)
+export const exitAsVoid = <A, E>(self: Exit.Exit<A, E>): Exit.Exit<void, E> => exitAs(self, void 0)
 
 /** @internal */
 export const exitCauseOption = <A, E>(self: Exit.Exit<A, E>): Option.Option<Cause.Cause<E>> => {
@@ -2578,7 +2579,7 @@ export const exitSucceed = <A>(value: A): Exit.Exit<A> => {
 }
 
 /** @internal */
-export const exitUnit: Exit.Exit<void> = exitSucceed(void 0)
+export const exitVoid: Exit.Exit<void> = exitSucceed(void 0)
 
 /** @internal */
 export const exitZip = dual<
@@ -2693,7 +2694,7 @@ const exitCollectAllInternal = <A, E>(
   }
   return pipe(
     Chunk.tailNonEmpty(list),
-    ReadonlyArray.reduce(
+    Array.reduce(
       pipe(Chunk.headNonEmpty(list), exitMap<A, Chunk.Chunk<A>>(Chunk.of)),
       (accumulator, current) =>
         pipe(
@@ -2705,7 +2706,7 @@ const exitCollectAllInternal = <A, E>(
         )
     ),
     exitMap(Chunk.reverse),
-    exitMap((chunk) => Array.from(chunk)),
+    exitMap((chunk) => Chunk.toReadonlyArray(chunk) as Array<A>),
     Option.some
   )
 }
@@ -2949,7 +2950,7 @@ export const mapInputContext = dual<
 /** @internal */
 export const currentSpanFromFiber = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Option.Option<Tracer.Span> => {
   const span = fiber.getFiberRef(currentContext).unsafeMap.get(internalTracer.spanTag.key) as
-    | Tracer.ParentSpan
+    | Tracer.AnySpan
     | undefined
   return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
 }
@@ -2966,7 +2967,7 @@ const NoopSpanProto: Tracer.Span = {
     _tag: "Ended",
     startTime: BigInt(0),
     endTime: BigInt(0),
-    exit: exitUnit
+    exit: exitVoid
   },
   attributes: new Map(),
   links: [],

package/src/internal/dataSource.ts

@@ -1,13 +1,12 @@
+import * as RA from "../Array.js"
 import * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import type * as Context from "../Context.js"
 import * as Effect from "../Effect.js"
 import type * as Either from "../Either.js"
 import { dual, pipe } from "../Function.js"
-import * as RA from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as RequestResolver from "../RequestResolver.js"
-import type { NoInfer } from "../Types.js"
 import * as core from "./core.js"
 import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
 import { complete } from "./request.js"
@@ -28,24 +27,24 @@ export const makeBatched = <A extends Request.Request<any, any>, R>(
   run: (requests: Array<A>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
   new core.RequestResolverImpl<A, R>(
-    (requests) =>
-      requests.length > 1 ?
-        core.forEachSequentialDiscard(requests, (block) =>
-          invokeWithInterrupt(
-            run(
-              block
-                .filter((_) => !_.state.completed)
-                .map((_) => _.request)
-            ),
-            block
-          )) :
-        (requests.length === 1 ?
-          run(
-            requests[0]
-              .filter((_) => !_.state.completed)
-              .map((_) => _.request)
-          ) :
-          core.unit)
+    (requests) => {
+      if (requests.length > 1) {
+        return core.forEachSequentialDiscard(requests, (block) => {
+          const filtered = block.filter((_) => !_.state.completed).map((_) => _.request)
+          if (filtered.length === 0) {
+            return core.void
+          }
+          return invokeWithInterrupt(run(filtered), block)
+        })
+      } else if (requests.length === 1) {
+        const filtered = requests[0].filter((_) => !_.state.completed).map((_) => _.request)
+        if (filtered.length === 0) {
+          return core.void
+        }
+        return run(filtered)
+      }
+      return core.void
+    }
   )
 
 /** @internal */

package/src/internal/differ/readonlyArrayPatch.ts

@@ -1,7 +1,7 @@
+import * as Array from "../../Array.js"
 import type * as Differ from "../../Differ.js"
 import * as Equal from "../../Equal.js"
 import * as Dual from "../../Function.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as Data from "../data.js"
 
 /** @internal */
@@ -135,7 +135,7 @@ export const diff = <Value, Patch>(
     patch = combine(patch, makeSlice(0, i))
   }
   if (i < options.newValue.length) {
-    patch = combine(patch, makeAppend(ReadonlyArray.drop(i)(options.newValue)))
+    patch = combine(patch, makeAppend(Array.drop(i)(options.newValue)))
   }
   return patch
 }
@@ -173,10 +173,10 @@ export const patch = Dual.dual<
     return oldValue
   }
   let readonlyArray = oldValue.slice()
-  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = ReadonlyArray.of(self)
-  while (ReadonlyArray.isNonEmptyArray(patches)) {
-    const head: Instruction = ReadonlyArray.headNonEmpty(patches) as Instruction
-    const tail = ReadonlyArray.tailNonEmpty(patches)
+  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = Array.of(self)
+  while (Array.isNonEmptyArray(patches)) {
+    const head: Instruction = Array.headNonEmpty(patches) as Instruction
+    const tail = Array.tailNonEmpty(patches)
     switch (head._tag) {
       case "Empty": {
         patches = tail

package/src/internal/effect/circular.ts

@@ -289,8 +289,8 @@ export const forkIn = dual<
             child.addFinalizer(() =>
               core.fiberIdWith((fiberId) =>
                 Equal.equals(fiberId, fiber.id()) ?
-                  core.unit :
-                  core.asUnit(core.interruptFiber(fiber))
+                  core.void :
+                  core.asVoid(core.interruptFiber(fiber))
               )
             )
           )

package/src/internal/executionStrategy.ts

@@ -46,27 +46,29 @@ export const isParallelN = (self: ExecutionStrategy.ExecutionStrategy): self is
 
 /** @internal */
 export const match = dual<
-  <A>(
-    onSequential: LazyArg<A>,
-    onParallel: LazyArg<A>,
-    onParallelN: (n: number) => A
-  ) => (self: ExecutionStrategy.ExecutionStrategy) => A,
+  <A>(options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }) => (self: ExecutionStrategy.ExecutionStrategy) => A,
   <A>(
     self: ExecutionStrategy.ExecutionStrategy,
-    onSequential: LazyArg<A>,
-    onParallel: LazyArg<A>,
-    onParallelN: (n: number) => A
+    options: {
+      readonly onSequential: LazyArg<A>
+      readonly onParallel: LazyArg<A>
+      readonly onParallelN: (n: number) => A
+    }
   ) => A
->(4, (self, onSequential, onParallel, onParallelN) => {
+>(2, (self, options) => {
   switch (self._tag) {
     case OP_SEQUENTIAL: {
-      return onSequential()
+      return options.onSequential()
     }
     case OP_PARALLEL: {
-      return onParallel()
+      return options.onParallel()
     }
     case OP_PARALLEL_N: {
-      return onParallelN(self.parallelism)
+      return options.onParallelN(self.parallelism)
     }
   }
 })

package/src/internal/fiber.ts

@@ -81,9 +81,9 @@ export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<A, E> => ({
   id: () => FiberId.none,
   await: core.succeed(exit),
   children: core.succeed([]),
-  inheritAll: core.unit,
+  inheritAll: core.void,
   poll: core.succeed(Option.some(exit)),
-  interruptAsFork: () => core.unit
+  interruptAsFork: () => core.void
 })
 
 /** @internal */
@@ -254,7 +254,7 @@ export const orElse = dual<
     pipe(
       core.interruptAsFiber(self, id),
       core.zipRight(pipe(that, core.interruptAsFiber(id))),
-      core.asUnit
+      core.asVoid
     )
 }))
 
@@ -334,8 +334,11 @@ export const status = <A, E>(self: Fiber.RuntimeFiber<A, E>): Effect.Effect<Fibe
 /** @internal */
 export const succeed = <A>(value: A): Fiber.Fiber<A> => done(Exit.succeed(value))
 
-/** @internal */
-export const unit: Fiber.Fiber<void> = succeed(void 0)
+const void_: Fiber.Fiber<void> = succeed(void 0)
+export {
+  /** @internal */
+  void_ as void
+}
 
 /** @internal */
 export const currentFiberURI = "effect/FiberCurrent"

package/src/internal/fiberRefs/patch.ts

@@ -1,9 +1,9 @@
+import * as Arr from "../../Array.js"
 import { equals } from "../../Equal.js"
 import type * as FiberId from "../../FiberId.js"
 import type * as FiberRefs from "../../FiberRefs.js"
 import type * as FiberRefsPatch from "../../FiberRefsPatch.js"
 import { dual } from "../../Function.js"
-import * as Arr from "../../ReadonlyArray.js"
 import * as _fiberRefs from "../fiberRefs.js"
 
 /** @internal */

package/src/internal/fiberRefs.ts

@@ -1,3 +1,4 @@
+import * as Arr from "../Array.js"
 import type * as Effect from "../Effect.js"
 import * as Equal from "../Equal.js"
 import type * as FiberId from "../FiberId.js"
@@ -7,7 +8,6 @@ import { dual, pipe } from "../Function.js"
 import * as HashSet from "../HashSet.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as Arr from "../ReadonlyArray.js"
 import * as core from "./core.js"
 
 /** @internal */