effect 2.0.0-next.56 → 2.0.0-next.57

package/src/internal/cause.ts

@@ -27,8 +27,8 @@ export const CauseTypeId: Cause.CauseTypeId = Symbol.for(
   CauseSymbolKey
 ) as Cause.CauseTypeId
 
-/** @internal */
 const variance = {
+  /* c8 ignore next */
   _E: (_: never) => _
 }
 

package/src/internal/channel/channelState.ts

@@ -1,6 +1,7 @@
 import * as Effect from "../../Effect.js"
 import type * as Exit from "../../Exit.js"
 import { hasProperty } from "../../Predicate.js"
+import type * as Types from "../../Types.js"
 import * as OpCodes from "../opCodes/channelState.js"
 import type { ErasedExecutor } from "./channelExecutor.js"
 
@@ -17,15 +18,16 @@ export interface ChannelState<out R, out E> extends ChannelState.Variance<R, E>
 export declare namespace ChannelState {
   export interface Variance<out R, out E> {
     readonly [ChannelStateTypeId]: {
-      readonly _R: (_: never) => R
-      readonly _E: (_: never) => E
+      readonly _R: Types.Covariant<R>
+      readonly _E: Types.Covariant<E>
     }
   }
 }
 
-/** @internal */
 const channelStateVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _
 }
 

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 */
@@ -38,15 +39,15 @@ export declare namespace Continuation {
     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>
     }
   }
 }
@@ -124,16 +125,24 @@ export interface ContinuationFinalizer<out Env, out OutErr, out OutDone> extends
   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) => _
 }
 

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() {
@@ -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"
@@ -313,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)
             })
@@ -610,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 {

package/src/internal/core-effect.ts

@@ -1629,7 +1629,6 @@ export const tryPromise: {
 ): Effect.Effect<never, E | Cause.UnknownException, A> => {
   let evaluate: (signal?: AbortSignal) => Promise<A>
   let catcher: ((error: unknown) => E) | undefined = undefined
-
   if (typeof arg === "function") {
     evaluate = arg as (signal?: AbortSignal) => Promise<A>
   } else {
@@ -1638,40 +1637,38 @@ export const tryPromise: {
   }
 
   if (evaluate.length >= 1) {
-    return core.suspend(() => {
-      const controller = new AbortController()
-      return core.flatMap(try_(() => evaluate(controller.signal)), (promise) =>
-        core.async((resolve) => {
-          promise
-            .then((a) => resolve(core.exitSucceed(a)))
-            .catch((e) =>
-              resolve(core.fail(
-                catcher ? catcher(e) : new core.UnknownException(e)
-              ))
-            )
-          return core.sync(() => controller.abort())
-        }))
-    })
-  }
-
-  return core.flatMap(
-    try_(
-      arg as {
-        readonly try: LazyArg<Promise<A>>
-        readonly catch: (error: unknown) => E
-      }
-    ),
-    (promise) =>
-      core.async<never, E, A>((resolve) => {
-        promise
+    return core.async((resolve, signal) => {
+      try {
+        evaluate(signal)
           .then((a) => resolve(core.exitSucceed(a)))
           .catch((e) =>
             resolve(core.fail(
-              catcher ? catcher(e) : e
+              catcher ? catcher(e) : new core.UnknownException(e)
             ))
           )
-      })
-  )
+      } catch (e) {
+        resolve(core.fail(
+          catcher ? catcher(e) : new core.UnknownException(e)
+        ))
+      }
+    })
+  }
+
+  return core.async((resolve) => {
+    try {
+      evaluate()
+        .then((a) => resolve(core.exitSucceed(a)))
+        .catch((e) =>
+          resolve(core.fail(
+            catcher ? catcher(e) : new core.UnknownException(e)
+          ))
+        )
+    } catch (e) {
+      resolve(core.fail(
+        catcher ? catcher(e) : new core.UnknownException(e)
+      ))
+    }
+  })
 }
 
 /* @internal */

package/src/internal/core-stream.ts

@@ -28,14 +28,20 @@ export const ChannelTypeId: Channel.ChannelTypeId = Symbol.for(
   ChannelSymbolKey
 ) as Channel.ChannelTypeId
 
-/** @internal */
 const channelVariance = {
+  /* 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 */
   _OutElem: (_: never) => _,
+  /* c8 ignore next */
   _OutDone: (_: never) => _
 }