effect 2.4.18 → 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,12 +35,13 @@ 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"
 import * as internalDiffer from "./differ.js"
 import { effectVariance, StructuralCommitPrototype } from "./effectable.js"
+import { getBugErrorMessage } from "./errors.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
@@ -429,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: {
@@ -469,7 +470,7 @@ export const custom: {
       break
     }
     default: {
-      throw new Error("Bug, you're not supposed to end up here")
+      throw new Error(getBugErrorMessage("you're not supposed to end up here"))
     }
   }
   return wrapper
@@ -514,7 +515,7 @@ export const async = <A, E = never, R = never>(
         if (controllerRef) {
           controllerRef.abort()
         }
-        return cancelerRef ?? unit
+        return cancelerRef ?? void_
       }) :
       effect
   })
@@ -885,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({
@@ -896,7 +897,7 @@ export const forEachSequential: {
             ret[i++] = b
           }
         }),
-        ret
+        ret as Array<B>
       )
     })
 )
@@ -909,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,
@@ -925,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 */
@@ -1064,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: {
@@ -1113,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_
     })
   ))
 
@@ -1157,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) {
@@ -1169,7 +1168,7 @@ export const partitionMap = <A, A1, A2>(
         }
       }
     },
-    [new Array<A1>(), new Array<A2>()]
+    [Array.empty<A1>(), Array.empty<A2>()]
   )
 
 /* @internal */
@@ -1301,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> => {
@@ -1667,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 */
@@ -1998,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 */
@@ -2066,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 = (
@@ -2086,143 +2088,6 @@ export const scopeFork = (
   strategy: ExecutionStrategy.ExecutionStrategy
 ): Effect.Effect<Scope.Scope.Closeable> => self.fork(strategy)
 
-// -----------------------------------------------------------------------------
-// ReleaseMap
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export type ReleaseMapState = {
-  _tag: "Exited"
-  nextKey: number
-  exit: Exit.Exit<unknown, unknown>
-  update: (finalizer: Scope.Scope.Finalizer) => Scope.Scope.Finalizer
-} | {
-  _tag: "Running"
-  nextKey: number
-  finalizers: Map<number, Scope.Scope.Finalizer>
-  update: (finalizer: Scope.Scope.Finalizer) => Scope.Scope.Finalizer
-}
-
-/** @internal */
-export interface ReleaseMap {
-  state: ReleaseMapState // mutable by design
-}
-
-/* @internal */
-export const releaseMapAdd = dual<
-  (finalizer: Scope.Scope.Finalizer) => (self: ReleaseMap) => Effect.Effect<Scope.Scope.Finalizer>,
-  (self: ReleaseMap, finalizer: Scope.Scope.Finalizer) => Effect.Effect<Scope.Scope.Finalizer>
->(2, (self, finalizer) =>
-  map(
-    releaseMapAddIfOpen(self, finalizer),
-    Option.match({
-      onNone: (): Scope.Scope.Finalizer => () => unit,
-      onSome: (key): Scope.Scope.Finalizer => (exit) => releaseMapRelease(key, exit)(self)
-    })
-  ))
-
-/* @internal */
-export const releaseMapRelease = dual<
-  (key: number, exit: Exit.Exit<unknown, unknown>) => (self: ReleaseMap) => Effect.Effect<void>,
-  (self: ReleaseMap, key: number, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>
->(3, (self, key, exit) =>
-  suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        return unit
-      }
-      case "Running": {
-        const finalizer = self.state.finalizers.get(key)
-        self.state.finalizers.delete(key)
-        if (finalizer != null) {
-          return self.state.update(finalizer)(exit)
-        }
-        return unit
-      }
-    }
-  }))
-
-/* @internal */
-export const releaseMapAddIfOpen = dual<
-  (finalizer: Scope.Scope.Finalizer) => (self: ReleaseMap) => Effect.Effect<Option.Option<number>>,
-  (self: ReleaseMap, finalizer: Scope.Scope.Finalizer) => Effect.Effect<Option.Option<number>>
->(2, (self, finalizer) =>
-  suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        self.state.nextKey += 1
-        return as(finalizer(self.state.exit), Option.none())
-      }
-      case "Running": {
-        const key = self.state.nextKey
-        self.state.finalizers.set(key, finalizer)
-        self.state.nextKey += 1
-        return succeed(Option.some(key))
-      }
-    }
-  }))
-
-/* @internal */
-export const releaseMapGet = dual<
-  (key: number) => (self: ReleaseMap) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>,
-  (self: ReleaseMap, key: number) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>
->(
-  2,
-  (self, key) =>
-    sync((): Option.Option<Scope.Scope.Finalizer> =>
-      self.state._tag === "Running" ? Option.fromNullable(self.state.finalizers.get(key)) : Option.none()
-    )
-)
-
-/* @internal */
-export const releaseMapReplace = dual<
-  (
-    key: number,
-    finalizer: Scope.Scope.Finalizer
-  ) => (self: ReleaseMap) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>,
-  (
-    self: ReleaseMap,
-    key: number,
-    finalizer: Scope.Scope.Finalizer
-  ) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>
->(3, (self, key, finalizer) =>
-  suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        return as(finalizer(self.state.exit), Option.none())
-      }
-      case "Running": {
-        const fin = Option.fromNullable(self.state.finalizers.get(key))
-        self.state.finalizers.set(key, finalizer)
-        return succeed(fin)
-      }
-    }
-  }))
-
-/* @internal */
-export const releaseMapRemove = dual<
-  (key: number) => (self: ReleaseMap) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>,
-  (self: ReleaseMap, key: number) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>
->(2, (self, key) =>
-  sync(() => {
-    if (self.state._tag === "Exited") {
-      return Option.none()
-    }
-    const fin = Option.fromNullable(self.state.finalizers.get(key))
-    self.state.finalizers.delete(key)
-    return fin
-  }))
-
-/* @internal */
-export const releaseMapMake: Effect.Effect<ReleaseMap> = sync((): ReleaseMap => ({
-  state: {
-    _tag: "Running",
-    nextKey: 0,
-    finalizers: new Map(),
-    update: identity
-  }
-}))
-
 // -----------------------------------------------------------------------------
 // Cause
 // -----------------------------------------------------------------------------
@@ -2245,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)
           },
@@ -2446,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>> => {
@@ -2714,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<
@@ -2829,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(
@@ -2841,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
   )
 }
@@ -2877,10 +2742,8 @@ export const deferredAwait = <A, E>(self: Deferred.Deferred<A, E>): Effect.Effec
         return resume(state.effect)
       }
       case DeferredOpCodes.OP_STATE_PENDING: {
-        pipe(
-          self.state,
-          MutableRef.set(deferred.pending([resume, ...state.joiners]))
-        )
+        // we can push here as the internal state is mutable
+        state.joiners.push(resume)
         return deferredInterruptJoiner(self, resume)
       }
     }
@@ -2908,8 +2771,8 @@ export const deferredCompleteWith = dual<
         return false
       }
       case DeferredOpCodes.OP_STATE_PENDING: {
-        pipe(self.state, MutableRef.set(deferred.done(effect)))
-        for (let i = 0; i < state.joiners.length; i++) {
+        MutableRef.set(self.state, deferred.done(effect))
+        for (let i = 0, len = state.joiners.length; i < len; i++) {
           state.joiners[i](effect)
         }
         return true
@@ -3005,8 +2868,8 @@ export const deferredSync = dual<
 export const deferredUnsafeDone = <A, E>(self: Deferred.Deferred<A, E>, effect: Effect.Effect<A, E>): void => {
   const state = MutableRef.get(self.state)
   if (state._tag === DeferredOpCodes.OP_STATE_PENDING) {
-    pipe(self.state, MutableRef.set(deferred.done(effect)))
-    for (let i = state.joiners.length - 1; i >= 0; i--) {
+    MutableRef.set(self.state, deferred.done(effect))
+    for (let i = 0, len = state.joiners.length; i < len; i++) {
       state.joiners[i](effect)
     }
   }
@@ -3019,10 +2882,11 @@ const deferredInterruptJoiner = <A, E>(
   sync(() => {
     const state = MutableRef.get(self.state)
     if (state._tag === DeferredOpCodes.OP_STATE_PENDING) {
-      pipe(
-        self.state,
-        MutableRef.set(deferred.pending(state.joiners.filter((j) => j !== joiner)))
-      )
+      const index = state.joiners.indexOf(joiner)
+      if (index >= 0) {
+        // we can splice here as the internal state is mutable
+        state.joiners.splice(index, 1)
+      }
     }
   })
 
@@ -3086,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()
 }
@@ -3103,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

@@ -15,6 +15,7 @@ import * as MutableHashMap from "../../MutableHashMap.js"
 import * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
 import * as Predicate from "../../Predicate.js"
+import * as Readable from "../../Readable.js"
 import type * as Ref from "../../Ref.js"
 import type * as Schedule from "../../Schedule.js"
 import { currentScheduler } from "../../Scheduler.js"
@@ -288,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))
               )
             )
           )
@@ -556,10 +557,15 @@ export const synchronizedVariance = {
 class SynchronizedImpl<in out A> implements Synchronized.SynchronizedRef<A> {
   readonly [SynchronizedTypeId] = synchronizedVariance
   readonly [internalRef.RefTypeId] = internalRef.refVariance
+  readonly [Readable.TypeId]: Readable.TypeId
   constructor(
     readonly ref: Ref.Ref<A>,
     readonly withLock: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  ) {}
+  ) {
+    this[Readable.TypeId] = Readable.TypeId
+    this.get = internalRef.get(this.ref)
+  }
+  readonly get: Effect.Effect<A>
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return this.modifyEffect((a) => core.succeed(f(a)))
   }

package/src/internal/errors.ts

@@ -0,0 +1,7 @@
+/**
+ * @since 2.0.0
+ */
+
+/** @internal */
+export const getBugErrorMessage = (message: string) =>
+  `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`

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)
     }
   }
 })