effect 2.0.0-next.55 → 2.0.0-next.57

package/src/internal/channel/continuation.ts

@@ -2,6 +2,7 @@ import type * as Cause from "../../Cause.js"
 import type * as Channel from "../../Channel.js"
 import type * as Effect from "../../Effect.js"
 import * as Exit from "../../Exit.js"
+import type * as Types from "../../Types.js"
 import * as OpCodes from "../opCodes/continuation.js"
 
 /** @internal */
@@ -11,24 +12,42 @@ 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
-      readonly _InElem: (_: InElem) => void
-      readonly _InDone: (_: InDone) => void
-      readonly _OutErr: (_: never) => OutErr
-      readonly _OutDone: (_: never) => OutDone
-      readonly _OutErr2: (_: never) => OutErr2
-      readonly _OutElem: (_: never) => OutElem
-      readonly _OutDone2: (_: never) => OutDone2
+      readonly _Env: Types.Covariant<Env>
+      readonly _InErr: Types.Contravariant<InErr>
+      readonly _InElem: Types.Contravariant<InElem>
+      readonly _InDone: Types.Contravariant<InDone>
+      readonly _OutErr: Types.Covariant<OutErr>
+      readonly _OutDone: Types.Covariant<OutDone>
+      readonly _OutErr2: Types.Covariant<OutErr2>
+      readonly _OutElem: Types.Covariant<OutElem>
+      readonly _OutDone2: Types.Covariant<OutDone2>
     }
   }
 }
@@ -54,15 +73,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 +96,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,34 +122,42 @@ 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 */
 const continuationVariance = {
+  /* c8 ignore next */
   _Env: (_: never) => _,
+  /* c8 ignore next */
   _InErr: (_: unknown) => _,
+  /* c8 ignore next */
   _InElem: (_: unknown) => _,
+  /* c8 ignore next */
   _InDone: (_: unknown) => _,
+  /* c8 ignore next */
   _OutErr: (_: never) => _,
+  /* c8 ignore next */
   _OutDone: (_: never) => _,
+  /* c8 ignore next */
   _OutErr2: (_: never) => _,
+  /* c8 ignore next */
   _OutElem: (_: never) => _,
+  /* c8 ignore next */
   _OutDone2: (_: never) => _
 }
 
 /** @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 +190,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/channel/upstreamPullRequest.ts

@@ -11,8 +11,8 @@ export const UpstreamPullRequestTypeId: UpstreamPullRequest.UpstreamPullRequestT
   UpstreamPullRequestSymbolKey
 ) as UpstreamPullRequest.UpstreamPullRequestTypeId
 
-/** @internal */
 const upstreamPullRequestVariance = {
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 

package/src/internal/channel/upstreamPullStrategy.ts

@@ -12,8 +12,8 @@ export const UpstreamPullStrategyTypeId: UpstreamPullStrategy.UpstreamPullStrate
   UpstreamPullStrategySymbolKey
 ) as UpstreamPullStrategy.UpstreamPullStrategyTypeId
 
-/** @internal */
 const upstreamPullStrategyVariance = {
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 

package/src/internal/config.ts

@@ -16,7 +16,6 @@ import * as configSecret from "./configSecret.js"
 import * as core from "./core.js"
 import * as OpCodes from "./opCodes/config.js"
 
-/** @internal */
 const ConfigSymbolKey = "effect/Config"
 
 /** @internal */
@@ -38,12 +37,11 @@ export type ConfigPrimitive =
   | Table
   | Zipped
 
-/** @internal */
 const configVariance = {
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 
-/** @internal */
 const proto = {
   [ConfigTypeId]: configVariance,
   pipe() {
@@ -60,7 +58,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 +83,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 +98,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 +114,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 +139,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
   }>
 {}
 
@@ -166,14 +164,14 @@ export const boolean = (name?: string): Config.Config<boolean> => {
         default: {
           const error = configError.InvalidData(
             [],
-            `Expected a boolean value, but received ${text}`
+            `Expected a boolean value but received ${text}`
           )
           return Either.left(error)
         }
       }
     }
   )
-  return name === undefined ? config : nested(name)(config)
+  return name === undefined ? config : nested(config, name)
 }
 
 /** @internal */
@@ -183,7 +181,7 @@ export const array = <A>(config: Config.Config<A>, name?: string): Config.Config
 
 /** @internal */
 export const chunk = <A>(config: Config.Config<A>, name?: string): Config.Config<Chunk.Chunk<A>> => {
-  return map(name === undefined ? repeat(config) : nested(name)(repeat(config)), Chunk.unsafeFromArray)
+  return map(name === undefined ? repeat(config) : nested(repeat(config), name), Chunk.unsafeFromArray)
 }
 
 /** @internal */
@@ -196,14 +194,14 @@ export const date = (name?: string): Config.Config<Date> => {
         return Either.left(
           configError.InvalidData(
             [],
-            `Expected a date value but received ${text}`
+            `Expected a Date value but received ${text}`
           )
         )
       }
       return Either.right(new Date(result))
     }
   )
-  return name === undefined ? config : nested(name)(config)
+  return name === undefined ? config : nested(config, name)
 }
 
 /** @internal */
@@ -225,14 +223,14 @@ export const number = (name?: string): Config.Config<number> => {
         return Either.left(
           configError.InvalidData(
             [],
-            `Expected an number value but received ${text}`
+            `Expected a number value but received ${text}`
           )
         )
       }
       return Either.right(result)
     }
   )
-  return name === undefined ? config : nested(name)(config)
+  return name === undefined ? config : nested(config, name)
 }
 
 /** @internal */
@@ -252,7 +250,7 @@ export const integer = (name?: string): Config.Config<number> => {
       return Either.right(result)
     }
   )
-  return name === undefined ? config : nested(name)(config)
+  return name === undefined ? config : nested(config, name)
 }
 
 /** @internal */
@@ -261,7 +259,7 @@ export const logLevel = (name?: string): Config.Config<LogLevel.LogLevel> => {
     const label = value.toUpperCase()
     const level = core.allLogLevels.find((level) => level.label === label)
     return level === undefined
-      ? Either.left(configError.InvalidData([], `Expected a log level, but found: ${value}`))
+      ? Either.left(configError.InvalidData([], `Expected a log level but received ${value}`))
       : Either.right(level)
   })
   return name === undefined ? config : nested(config, name)
@@ -303,13 +301,6 @@ export const mapOrFail = dual<
   return mapOrFail
 })
 
-/** @internal */
-export const missingError = (name: string) => {
-  return <A>(self: Config.Config.Primitive<A>): ConfigError.ConfigError => {
-    return configError.MissingData([], `Expected ${self.description} with name ${name}`)
-  }
-}
-
 /** @internal */
 export const nested = dual<
   (name: string) => <A>(self: Config.Config<A>) => Config.Config<A>,
@@ -394,13 +385,13 @@ export const secret = (name?: string): Config.Config<ConfigSecret.ConfigSecret>
     "a secret property",
     (text) => Either.right(configSecret.fromString(text))
   )
-  return name === undefined ? config : nested(name)(config)
+  return name === undefined ? config : nested(config, name)
 }
 
 /** @internal */
 export const hashSet = <A>(config: Config.Config<A>, name?: string): Config.Config<HashSet.HashSet<A>> => {
   const newConfig = map(chunk(config), HashSet.fromIterable)
-  return name === undefined ? newConfig : nested(name)(newConfig)
+  return name === undefined ? newConfig : nested(newConfig, name)
 }
 
 /** @internal */
@@ -409,9 +400,10 @@ export const string = (name?: string): Config.Config<string> => {
     "a text property",
     Either.right
   )
-  return name === undefined ? config : nested(name)(config)
+  return name === undefined ? config : nested(config, name)
 }
 
+/** @internal */
 export const all = <const Arg extends Iterable<Config.Config<any>> | Record<string, Config.Config<any>>>(
   arg: Arg
 ): Config.Config<
@@ -479,7 +471,7 @@ export const hashMap = <A>(config: Config.Config<A>, name?: string): Config.Conf
   const table = Object.create(proto)
   table._tag = OpCodes.OP_HASHMAP
   table.valueConfig = config
-  return name === undefined ? table : nested(name)(table)
+  return name === undefined ? table : nested(table, name)
 }
 
 /** @internal */

package/src/internal/configError.ts

@@ -166,10 +166,10 @@ export const prefixed: {
 >(2, (self, prefix) => {
   switch (self._tag) {
     case OpCodes.OP_AND: {
-      return And(prefixed(prefix)(self.left), prefixed(prefix)(self.right))
+      return And(prefixed(self.left, prefix), prefixed(self.right, prefix))
     }
     case OpCodes.OP_OR: {
-      return Or(prefixed(prefix)(self.left), prefixed(prefix)(self.right))
+      return Or(prefixed(self.left, prefix), prefixed(self.right, prefix))
     }
     case OpCodes.OP_INVALID_DATA: {
       return InvalidData([...prefix, ...self.path], self.message)

package/src/internal/configProvider.ts

@@ -13,7 +13,7 @@ import * as number from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as RA from "../ReadonlyArray.js"
-import * as _config from "./config.js"
+import type * as _config from "./config.js"
 import * as configError from "./configError.js"
 import * as pathPatch from "./configProvider/pathPatch.js"
 import * as core from "./core.js"
@@ -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)))
               )
             )
           )
@@ -300,7 +313,7 @@ const fromFlatLoop = <A>(
             core.flatMap((values) => {
               if (values.length === 0) {
                 const name = pipe(RA.last(prefix), Option.getOrElse(() => "<n/a>"))
-                return core.fail(_config.missingError(name))
+                return core.fail(configError.MissingData([], `Expected ${op.description} with name ${name}`))
               }
               return core.succeed(values)
             })
@@ -597,8 +610,10 @@ const parsePrimitive = <A>(
   if (!split) {
     return pipe(
       primitive.parse(text),
-      core.map(RA.of),
-      core.mapError(configError.prefixed(path))
+      core.mapBoth({
+        onFailure: configError.prefixed(path),
+        onSuccess: RA.of
+      })
     )
   }
   return pipe(

package/src/internal/context.ts

@@ -3,7 +3,7 @@ import * as Equal from "../Equal.js"
 import { dual } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type * as O from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -29,11 +29,11 @@ export const TagProto: C.Tag<unknown, unknown> = {
   _op: "Tag",
   [STMTypeId]: effectVariance,
   [TagTypeId]: {
-    _S: (_: unknown) => _,
-    _I: (_: unknown) => _
+    _Service: (_: unknown) => _,
+    _Identifier: (_: unknown) => _
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON<I, A>(this: C.Tag<I, A>) {
     return {
@@ -86,7 +86,7 @@ export const TypeId: C.TypeId = Symbol.for("effect/Context") as C.TypeId
 /** @internal */
 export const ContextProto: Omit<C.Context<unknown>, "unsafeMap"> = {
   [TypeId]: {
-    _S: (_: unknown) => _
+    _Services: (_: unknown) => _
   },
   [Equal.symbol]<A>(this: C.Context<A>, that: unknown): boolean {
     if (isContext(that)) {
@@ -108,7 +108,7 @@ export const ContextProto: Omit<C.Context<unknown>, "unsafeMap"> = {
     return pipeArguments(this, arguments)
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON<A>(this: C.Context<A>) {
     return {