effect 2.0.0-next.55 → 2.0.0-next.56

package/src/internal/cause.ts

@@ -2,14 +2,14 @@ import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
-import * as FiberId from "../FiberId.js"
+import type * as FiberId from "../FiberId.js"
 import { constFalse, constTrue, dual, identity, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
 import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isFunction, isString, type Predicate } from "../Predicate.js"
+import { hasProperty, isFunction, type Predicate } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as OpCodes from "./opCodes/cause.js"
 
@@ -485,6 +485,18 @@ export const flatMap = dual<
 /** @internal */
 export const flatten = <E>(self: Cause.Cause<Cause.Cause<E>>): Cause.Cause<E> => flatMap(self, identity)
 
+/** @internal */
+export const andThen: {
+  <E, E2>(f: (e: E) => Cause.Cause<E2>): (self: Cause.Cause<E>) => Cause.Cause<E2>
+  <E2>(f: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E2>
+  <E, E2>(self: Cause.Cause<E>, f: (e: E) => Cause.Cause<E2>): Cause.Cause<E2>
+  <E, E2>(self: Cause.Cause<E>, f: Cause.Cause<E2>): Cause.Cause<E2>
+} = dual(
+  2,
+  <E, E2>(self: Cause.Cause<E>, f: ((e: E) => Cause.Cause<E2>) | Cause.Cause<E2>): Cause.Cause<E2> =>
+    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
+)
+
 // -----------------------------------------------------------------------------
 // Equality
 // -----------------------------------------------------------------------------
@@ -593,43 +605,6 @@ const flattenCauseLoop = (
   throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
 }
 
-// -----------------------------------------------------------------------------
-// Squashing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const squash = <E>(self: Cause.Cause<E>): unknown => {
-  return squashWith(identity)(self)
-}
-
-/** @internal */
-export const squashWith = dual<
-  <E>(f: (error: E) => unknown) => (self: Cause.Cause<E>) => unknown,
-  <E>(self: Cause.Cause<E>, f: (error: E) => unknown) => unknown
->(2, (self, f) => {
-  const option = pipe(self, failureOption, Option.map(f))
-  switch (option._tag) {
-    case "None": {
-      return pipe(
-        defects(self),
-        Chunk.head,
-        Option.match({
-          onNone: () => {
-            const interrupts = Array.from(interruptors(self)).flatMap((fiberId) =>
-              Array.from(FiberId.ids(fiberId)).map((id) => `#${id}`)
-            )
-            return InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0)
-          },
-          onSome: identity
-        })
-      )
-    }
-    case "Some": {
-      return option.value
-    }
-  }
-})
-
 // -----------------------------------------------------------------------------
 // Finding
 // -----------------------------------------------------------------------------
@@ -978,105 +953,6 @@ export const reduceWithContext = dual<
   return accumulator.pop()!
 })
 
-// -----------------------------------------------------------------------------
-// Errors
-// -----------------------------------------------------------------------------
-
-const makeException = <T extends { _tag: string; message?: string }>(
-  proto: Omit<T, "message" | "_tag">,
-  tag: T["_tag"]
-) => {
-  const _tag = {
-    value: tag,
-    enumerable: true
-  }
-  const protoWithToString = {
-    ...proto,
-    toString(this: { _tag: string; message?: string }): string {
-      return `${this._tag}: ${this.message}`
-    }
-  }
-  return (message?: string): T => {
-    const properties: PropertyDescriptorMap = { _tag }
-    if (isString(message)) {
-      properties["message"] = {
-        value: message,
-        enumerable: true
-      }
-    }
-    return Object.create(protoWithToString, properties)
-  }
-}
-
-/** @internal */
-export const RuntimeExceptionTypeId: Cause.RuntimeExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/RuntimeException"
-) as Cause.RuntimeExceptionTypeId
-
-/** @internal */
-export const RuntimeException = makeException<Cause.RuntimeException>({
-  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
-}, "RuntimeException")
-
-/** @internal */
-export const isRuntimeException = (u: unknown): u is Cause.RuntimeException => hasProperty(u, RuntimeExceptionTypeId)
-
-/** @internal */
-export const InterruptedExceptionTypeId: Cause.InterruptedExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/InterruptedException"
-) as Cause.InterruptedExceptionTypeId
-
-/** @internal */
-export const InterruptedException = makeException<Cause.InterruptedException>({
-  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
-}, "InterruptedException")
-
-/** @internal */
-export const isInterruptedException = (u: unknown): u is Cause.InterruptedException =>
-  hasProperty(u, InterruptedExceptionTypeId)
-
-/** @internal */
-export const IllegalArgumentExceptionTypeId: Cause.IllegalArgumentExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/IllegalArgument"
-) as Cause.IllegalArgumentExceptionTypeId
-
-/** @internal */
-export const IllegalArgumentException = makeException<Cause.IllegalArgumentException>({
-  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
-}, "IllegalArgumentException")
-
-/** @internal */
-export const isIllegalArgumentException = (u: unknown): u is Cause.IllegalArgumentException =>
-  hasProperty(u, IllegalArgumentExceptionTypeId)
-
-/** @internal */
-export const NoSuchElementExceptionTypeId: Cause.NoSuchElementExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/NoSuchElement"
-) as Cause.NoSuchElementExceptionTypeId
-
-/** @internal */
-export const NoSuchElementException = makeException<Cause.NoSuchElementException>({
-  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
-}, "NoSuchElementException")
-
-/** @internal */
-export const isNoSuchElementException = (u: unknown): u is Cause.NoSuchElementException =>
-  hasProperty(u, NoSuchElementExceptionTypeId)
-
-/** @internal */
-export const InvalidPubSubCapacityExceptionTypeId: Cause.InvalidPubSubCapacityExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/InvalidPubSubCapacityException"
-) as Cause.InvalidPubSubCapacityExceptionTypeId
-
-/** @internal */
-export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubCapacityException>({
-  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
-}, "InvalidPubSubCapacityException")
-
-/** @internal */
-export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
-  hasProperty(u, InvalidPubSubCapacityExceptionTypeId)
-
 // -----------------------------------------------------------------------------
 // Pretty Printing
 // -----------------------------------------------------------------------------

package/src/internal/channel/channelExecutor.ts

@@ -60,7 +60,7 @@ export type ErasedContinuation<R> = Continuation.Continuation<
 export type ErasedFinalizer<R> = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R, never, unknown>
 
 /** @internal */
-export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
   private _activeSubexecutor: Subexecutor.Subexecutor<Env> | undefined = undefined
 
   private _cancelled: Exit.Exit<OutErr, OutDone> | undefined = undefined

package/src/internal/channel/channelState.ts

@@ -11,11 +11,11 @@ export const ChannelStateTypeId = Symbol.for("effect/ChannelState")
 export type ChannelStateTypeId = typeof ChannelStateTypeId
 
 /** @internal */
-export interface ChannelState<R, E> extends ChannelState.Variance<R, E> {}
+export interface ChannelState<out R, out E> extends ChannelState.Variance<R, E> {}
 
 /** @internal */
 export declare namespace ChannelState {
-  export interface Variance<R, E> {
+  export interface Variance<out R, out E> {
     readonly [ChannelStateTypeId]: {
       readonly _R: (_: never) => R
       readonly _E: (_: never) => E
@@ -63,9 +63,9 @@ export interface FromEffect extends
 export interface Read extends
   Op<OpCodes.OP_READ, {
     readonly upstream: ErasedExecutor<unknown>
-    readonly onEffect: (effect: Effect.Effect<unknown, never, void>) => Effect.Effect<unknown, never, void>
-    readonly onEmit: (value: unknown) => Effect.Effect<unknown, never, void>
-    readonly onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, void>
+    onEffect(effect: Effect.Effect<unknown, never, void>): Effect.Effect<unknown, never, void>
+    onEmit(value: unknown): Effect.Effect<unknown, never, void>
+    onDone(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, void>
   }>
 {}
 

package/src/internal/channel/continuation.ts

@@ -11,14 +11,32 @@ export const ContinuationTypeId = Symbol.for("effect/ChannelContinuation")
 export type ContinuationTypeId = typeof ContinuationTypeId
 
 /** @internal */
-export interface Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>
-  extends Continuation.Variance<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>
-{}
+export interface Continuation<
+  out Env,
+  in InErr,
+  in InElem,
+  in InDone,
+  out OutErr,
+  out OutErr2,
+  out OutElem,
+  out OutDone,
+  out OutDone2
+> extends Continuation.Variance<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {}
 
 /** @internal */
 export declare namespace Continuation {
   /** @internal */
-  export interface Variance<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
+  export interface Variance<
+    out Env,
+    in InErr,
+    in InElem,
+    in InDone,
+    out OutErr,
+    out OutErr2,
+    out OutElem,
+    out OutDone,
+    out OutDone2
+  > {
     readonly [ContinuationTypeId]: {
       readonly _Env: (_: never) => Env
       readonly _InErr: (_: InErr) => void
@@ -54,15 +72,15 @@ export type ErasedContinuationFinalizer = ContinuationFinalizer<unknown, unknown
 
 /** @internal */
 export interface ContinuationK<
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  OutErr2,
-  OutElem,
-  OutDone,
-  OutDone2
+  out Env,
+  in InErr,
+  in InElem,
+  in InDone,
+  out OutErr,
+  out OutErr2,
+  out OutElem,
+  out OutDone,
+  out OutDone2
 > extends
   Continuation<
     Env,
@@ -77,19 +95,19 @@ export interface ContinuationK<
   >
 {
   readonly _tag: OpCodes.OP_CONTINUATION_K
-  readonly onSuccess: (
+  onSuccess(
     o: OutDone
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
-  readonly onHalt: (
+  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  onHalt(
     c: Cause.Cause<OutErr>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
-  readonly onExit: (
+  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  onExit(
     exit: Exit.Exit<OutErr, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
 }
 
 /** @internal */
-export interface ContinuationFinalizer<Env, OutErr, OutDone> extends
+export interface ContinuationFinalizer<out Env, out OutErr, out OutDone> extends
   Continuation<
     Env,
     unknown,
@@ -103,7 +121,7 @@ export interface ContinuationFinalizer<Env, OutErr, OutDone> extends
   >
 {
   readonly _tag: OpCodes.OP_CONTINUATION_FINALIZER
-  readonly finalizer: (exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env, never, unknown>
+  finalizer(exit: Exit.Exit<OutErr, OutDone>): Effect.Effect<Env, never, unknown>
 }
 
 /** @internal */
@@ -121,16 +139,16 @@ const continuationVariance = {
 
 /** @internal */
 export class ContinuationKImpl<
-  Env,
-  Env2,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  OutErr2,
-  OutElem,
-  OutDone,
-  OutDone2
+  out Env,
+  out Env2,
+  in InErr,
+  in InElem,
+  in InDone,
+  in out OutErr,
+  out OutErr2,
+  out OutElem,
+  in out OutDone,
+  out OutDone2
 > implements
   ContinuationK<
     Env | Env2,
@@ -163,7 +181,9 @@ export class ContinuationKImpl<
 }
 
 /** @internal */
-export class ContinuationFinalizerImpl<Env, OutErr, OutDone> implements ContinuationFinalizer<Env, OutErr, OutDone> {
+export class ContinuationFinalizerImpl<out Env, in out OutErr, in out OutDone>
+  implements ContinuationFinalizer<Env, OutErr, OutDone>
+{
   readonly _tag = OpCodes.OP_CONTINUATION_FINALIZER
   readonly [ContinuationTypeId] = continuationVariance
   constructor(readonly finalizer: (exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env, never, unknown>) {

package/src/internal/channel/mergeDecision.ts

@@ -47,7 +47,7 @@ export interface Done extends
 /** @internal */
 export interface Await extends
   Op<OpCodes.OP_AWAIT, {
-    readonly f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, never>
+    f(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never, never, never>
   }>
 {}
 

package/src/internal/channel/singleProducerAsyncInput.ts

@@ -89,7 +89,7 @@ const stateDone = <Done>(done: Done): State<never, never, Done> => ({
 })
 
 /** @internal */
-class SingleProducerAsyncInputImpl<Err, Elem, Done>
+class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
   implements SingleProducerAsyncInput.SingleProducerAsyncInput<Err, Elem, Done>
 {
   constructor(readonly ref: Ref.Ref<State<Err, Elem, Done>>) {

package/src/internal/channel/subexecutor.ts

@@ -7,9 +7,9 @@ import type * as UpstreamPullStrategy from "../../UpstreamPullStrategy.js"
 import type { ErasedChannel, ErasedExecutor } from "./channelExecutor.js"
 
 /** @internal */
-export interface Subexecutor<R> {
-  readonly close: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R, never, unknown> | undefined
-  readonly enqueuePullFromChild: (child: PullFromChild<R>) => Subexecutor<R>
+export interface Subexecutor<in out R> {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined
+  enqueuePullFromChild(child: PullFromChild<R>): Subexecutor<R>
 }
 
 /** @internal */
@@ -45,7 +45,7 @@ export type OP_EMIT = typeof OP_EMIT
  *
  * @internal
  */
-export class PullFromChild<R> implements Subexecutor<R> {
+export class PullFromChild<in out R> implements Subexecutor<R> {
   readonly _tag: OP_PULL_FROM_CHILD = OP_PULL_FROM_CHILD
 
   constructor(
@@ -84,7 +84,7 @@ export class PullFromChild<R> implements Subexecutor<R> {
  *
  * @internal
  */
-export class PullFromUpstream<R> implements Subexecutor<R> {
+export class PullFromUpstream<in out R> implements Subexecutor<R> {
   readonly _tag: OP_PULL_FROM_UPSTREAM = OP_PULL_FROM_UPSTREAM
 
   constructor(
@@ -152,7 +152,7 @@ export class PullFromUpstream<R> implements Subexecutor<R> {
  *
  * @internal
  */
-export class DrainChildExecutors<R> implements Subexecutor<R> {
+export class DrainChildExecutors<in out R> implements Subexecutor<R> {
   readonly _tag: OP_DRAIN_CHILD_EXECUTORS = OP_DRAIN_CHILD_EXECUTORS
 
   constructor(
@@ -212,7 +212,7 @@ export class DrainChildExecutors<R> implements Subexecutor<R> {
 }
 
 /** @internal */
-export class Emit<R> implements Subexecutor<R> {
+export class Emit<in out R> implements Subexecutor<R> {
   readonly _tag: OP_EMIT = OP_EMIT
 
   constructor(readonly value: unknown, readonly next: Subexecutor<R>) {

package/src/internal/config.ts

@@ -60,7 +60,7 @@ export type Op<Tag extends string, Body = {}> = Config.Config<never> & Body & {
 export interface Constant extends
   Op<OpCodes.OP_CONSTANT, {
     readonly value: unknown
-    readonly parse: (text: string) => Either.Either<ConfigError.ConfigError, unknown>
+    parse(text: string): Either.Either<ConfigError.ConfigError, unknown>
   }>
 {}
 
@@ -85,14 +85,14 @@ export interface Fallback extends
 export interface Fail extends
   Op<OpCodes.OP_FAIL, {
     readonly message: string
-    readonly parse: (text: string) => Either.Either<ConfigError.ConfigError, unknown>
+    parse(text: string): Either.Either<ConfigError.ConfigError, unknown>
   }>
 {}
 
 /** @internal */
 export interface Lazy extends
   Op<OpCodes.OP_LAZY, {
-    readonly config: LazyArg<Config.Config<unknown>>
+    config(): Config.Config<unknown>
   }>
 {}
 
@@ -100,7 +100,7 @@ export interface Lazy extends
 export interface MapOrFail extends
   Op<OpCodes.OP_MAP_OR_FAIL, {
     readonly original: Config.Config<unknown>
-    readonly mapOrFail: (value: unknown) => Either.Either<ConfigError.ConfigError, unknown>
+    mapOrFail(value: unknown): Either.Either<ConfigError.ConfigError, unknown>
   }>
 {}
 
@@ -116,7 +116,7 @@ export interface Nested extends
 export interface Primitive extends
   Op<OpCodes.OP_PRIMITIVE, {
     readonly description: string
-    readonly parse: (text: string) => Either.Either<ConfigError.ConfigError, unknown>
+    parse(text: string): Either.Either<ConfigError.ConfigError, unknown>
   }>
 {}
 
@@ -141,7 +141,7 @@ export interface Zipped extends
     readonly op: OpCodes.OP_ZIP_WITH
     readonly left: Config.Config<unknown>
     readonly right: Config.Config<unknown>
-    readonly zip: (a: unknown, b: unknown) => unknown
+    zip(a: unknown, b: unknown): unknown
   }>
 {}
 

package/src/internal/configProvider.ts

@@ -218,6 +218,19 @@ const extend = <A, B>(
   return [leftExtension, rightExtension]
 }
 
+const appendConfigPath = (path: ReadonlyArray<string>, config: Config.Config<unknown>): ReadonlyArray<string> => {
+  let op = config as _config.ConfigPrimitive
+  if (op._tag === "Nested") {
+    const out = path.slice()
+    while (op._tag === "Nested") {
+      out.push(op.name)
+      op = op.config as _config.ConfigPrimitive
+    }
+    return out
+  }
+  return path
+}
+
 const fromFlatLoop = <A>(
   flat: ConfigProvider.ConfigProvider.Flat,
   prefix: ReadonlyArray<string>,
@@ -274,7 +287,7 @@ const fromFlatLoop = <A>(
             core.forEachSequential((a) =>
               pipe(
                 op.mapOrFail(a),
-                core.mapError(configError.prefixed(prefix))
+                core.mapError(configError.prefixed(appendConfigPath(prefix, op.original)))
               )
             )
           )