effect 2.2.5 → 2.3.1

package/src/internal/clock.ts

@@ -14,7 +14,7 @@ const ClockSymbolKey = "effect/Clock"
 export const ClockTypeId: Clock.ClockTypeId = Symbol.for(ClockSymbolKey) as Clock.ClockTypeId
 
 /** @internal */
-export const clockTag: Context.Tag<Clock.Clock, Clock.Clock> = Context.Tag(ClockTypeId)
+export const clockTag: Context.Tag<Clock.Clock, Clock.Clock> = Context.GenericTag("effect/Clock")
 
 /** @internal */
 export const MAX_TIMER_MILLIS = 2 ** 31 - 1
@@ -77,16 +77,16 @@ class ClockImpl implements Clock.Clock {
     return processOrPerformanceNow()
   }
 
-  currentTimeMillis: Effect.Effect<never, never, number> = core.sync(() => this.unsafeCurrentTimeMillis())
+  currentTimeMillis: Effect.Effect<number> = core.sync(() => this.unsafeCurrentTimeMillis())
 
-  currentTimeNanos: Effect.Effect<never, never, bigint> = core.sync(() => this.unsafeCurrentTimeNanos())
+  currentTimeNanos: Effect.Effect<bigint> = core.sync(() => this.unsafeCurrentTimeNanos())
 
-  scheduler(): Effect.Effect<never, never, Clock.ClockScheduler> {
+  scheduler(): Effect.Effect<Clock.ClockScheduler> {
     return core.succeed(globalClockScheduler)
   }
 
-  sleep(duration: Duration.Duration): Effect.Effect<never, never, void> {
-    return core.asyncEither<never, never, void>((cb) => {
+  sleep(duration: Duration.Duration): Effect.Effect<void> {
+    return core.asyncEither<void>((cb) => {
       const canceler = globalClockScheduler.unsafeSchedule(() => cb(core.unit), duration)
       return Either.left(core.asUnit(core.sync(canceler)))
     })

package/src/internal/concurrency.ts

@@ -3,12 +3,12 @@ import type { Concurrency } from "../Types.js"
 import * as core from "./core.js"
 
 /** @internal */
-export const match = <R, E, A>(
+export const match = <A, E, R>(
   concurrency: Concurrency | undefined,
-  sequential: () => Effect<R, E, A>,
-  unbounded: () => Effect<R, E, A>,
-  bounded: (limit: number) => Effect<R, E, A>
-): Effect<R, E, A> => {
+  sequential: () => Effect<A, E, R>,
+  unbounded: () => Effect<A, E, R>,
+  bounded: (limit: number) => Effect<A, E, R>
+): Effect<A, E, R> => {
   switch (concurrency) {
     case undefined:
       return sequential()
@@ -30,11 +30,11 @@ export const match = <R, E, A>(
 }
 
 /** @internal */
-export const matchSimple = <R, E, A>(
+export const matchSimple = <A, E, R>(
   concurrency: Concurrency | undefined,
-  sequential: () => Effect<R, E, A>,
-  concurrent: () => Effect<R, E, A>
-): Effect<R, E, A> => {
+  sequential: () => Effect<A, E, R>,
+  concurrent: () => Effect<A, E, R>
+): Effect<A, E, R> => {
   switch (concurrency) {
     case undefined:
       return sequential()

package/src/internal/configProvider.ts

@@ -33,9 +33,10 @@ export const ConfigProviderTypeId: ConfigProvider.ConfigProviderTypeId = Symbol.
 ) as ConfigProvider.ConfigProviderTypeId
 
 /** @internal */
-export const configProviderTag: Context.Tag<ConfigProvider.ConfigProvider, ConfigProvider.ConfigProvider> = Context.Tag(
-  ConfigProviderTypeId
-)
+export const configProviderTag: Context.Tag<ConfigProvider.ConfigProvider, ConfigProvider.ConfigProvider> = Context
+  .GenericTag(
+    "effect/ConfigProvider"
+  )
 
 /** @internal */
 const FlatConfigProviderSymbolKey = "effect/ConfigProviderFlat"
@@ -48,7 +49,7 @@ export const FlatConfigProviderTypeId: ConfigProvider.FlatConfigProviderTypeId =
 /** @internal */
 export const make = (
   options: {
-    readonly load: <A>(config: Config.Config<A>) => Effect.Effect<never, ConfigError.ConfigError, A>
+    readonly load: <A>(config: Config.Config<A>) => Effect.Effect<A, ConfigError.ConfigError>
     readonly flattened: ConfigProvider.ConfigProvider.Flat
   }
 ): ConfigProvider.ConfigProvider => ({
@@ -66,10 +67,10 @@ export const makeFlat = (
       path: ReadonlyArray<string>,
       config: Config.Config.Primitive<A>,
       split: boolean
-    ) => Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+    ) => Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     readonly enumerateChildren: (
       path: ReadonlyArray<string>
-    ) => Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>>
+    ) => Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError>
     readonly patch: PathPatch.PathPatch
   }
 ): ConfigProvider.ConfigProvider.Flat => ({
@@ -112,7 +113,7 @@ export const fromEnv = (
     path: ReadonlyArray<string>,
     primitive: Config.Config.Primitive<A>,
     split = true
-  ): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>> => {
+  ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
     const pathString = makePathString(path)
     const current = getEnv()
     const valueOpt = pathString in current ? Option.some(current[pathString]!) : Option.none()
@@ -125,7 +126,7 @@ export const fromEnv = (
 
   const enumerateChildren = (
     path: ReadonlyArray<string>
-  ): Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>> =>
+  ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
     core.sync(() => {
       const current = getEnv()
       const keys = Object.keys(current)
@@ -163,7 +164,7 @@ export const fromMap = (
     path: ReadonlyArray<string>,
     primitive: Config.Config.Primitive<A>,
     split = true
-  ): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>> => {
+  ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
     const pathString = makePathString(path)
     const valueOpt = mapWithIndexSplit.has(pathString) ?
       Option.some(mapWithIndexSplit.get(pathString)!) :
@@ -176,7 +177,7 @@ export const fromMap = (
   }
   const enumerateChildren = (
     path: ReadonlyArray<string>
-  ): Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>> =>
+  ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
     core.sync(() => {
       const keyPaths = Array.from(mapWithIndexSplit.keys()).map(unmakePathString)
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
@@ -238,26 +239,21 @@ const fromFlatLoop = <A>(
   prefix: ReadonlyArray<string>,
   config: Config.Config<A>,
   split: boolean
-): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>> => {
+): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(ReadonlyArray.of(op.value)) as Effect.Effect<
-        never,
-        ConfigError.ConfigError,
-        ReadonlyArray<A>
-      >
+      return core.succeed(ReadonlyArray.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_DESCRIBED: {
       return core.suspend(
         () => fromFlatLoop(flat, prefix, op.config, split)
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_FAIL: {
       return core.fail(configError.MissingData(prefix, op.message)) as Effect.Effect<
-        never,
-        ConfigError.ConfigError,
-        ReadonlyArray<A>
+        ReadonlyArray<A>,
+        ConfigError.ConfigError
       >
     }
     case OpCodes.OP_FALLBACK: {
@@ -272,13 +268,12 @@ const fromFlatLoop = <A>(
           }
           return core.fail(error1)
         })
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_LAZY: {
       return core.suspend(() => fromFlatLoop(flat, prefix, op.config(), split)) as Effect.Effect<
-        never,
-        ConfigError.ConfigError,
-        ReadonlyArray<A>
+        ReadonlyArray<A>,
+        ConfigError.ConfigError
       >
     }
     case OpCodes.OP_MAP_OR_FAIL: {
@@ -294,7 +289,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_NESTED: {
       return core.suspend(() =>
@@ -304,7 +299,7 @@ const fromFlatLoop = <A>(
           op.config,
           split
         )
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_PRIMITIVE: {
       return pipe(
@@ -321,7 +316,7 @@ const fromFlatLoop = <A>(
             })
           )
         )
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_SEQUENCE: {
       return pipe(
@@ -334,7 +329,7 @@ const fromFlatLoop = <A>(
               if (indices.length === 0) {
                 return core.suspend(() =>
                   core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), ReadonlyArray.of)
-                ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+                ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
@@ -348,7 +343,7 @@ const fromFlatLoop = <A>(
                   }
                   return ReadonlyArray.of(flattened)
                 })
-              ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+              ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
             })
           )
         )
@@ -389,7 +384,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_ZIP_WITH: {
       return core.suspend(() =>
@@ -437,7 +432,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
   }
 }
@@ -610,7 +605,7 @@ const parsePrimitive = <A>(
   primitive: Config.Config.Primitive<A>,
   delimiter: string,
   split: boolean
-): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>> => {
+): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
   if (!split) {
     return pipe(
       primitive.parse(text),
@@ -631,11 +626,9 @@ const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<Rea
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const escapeRegex = (string: string): string => {
-  return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
-}
+const escapeRegex = (string: string): string => string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
 
-const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<never, never, ReadonlyArray<number>> =>
+const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({

package/src/internal/console.ts

@@ -11,13 +11,13 @@ import * as fiberRuntime from "./fiberRuntime.js"
 import * as layer from "./layer.js"
 
 /** @internal */
-export const console: Effect.Effect<never, never, Console.Console> = core.map(
+export const console: Effect.Effect<Console.Console> = core.map(
   core.fiberRefGet(defaultServices.currentServices),
   Context.get(defaultConsole.consoleTag)
 )
 
 /** @internal */
-export const consoleWith = <R, E, A>(f: (console: Console.Console) => Effect.Effect<R, E, A>) =>
+export const consoleWith = <A, E, R>(f: (console: Console.Console) => Effect.Effect<A, E, R>) =>
   core.fiberRefGetWith(
     defaultServices.currentServices,
     (services) => f(Context.get(services, defaultConsole.consoleTag))
@@ -25,8 +25,8 @@ export const consoleWith = <R, E, A>(f: (console: Console.Console) => Effect.Eff
 
 /** @internal */
 export const withConsole = dual<
-  <A extends Console.Console>(console: A) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A extends Console.Console>(effect: Effect.Effect<R, E, A>, console: A) => Effect.Effect<R, E, A>
+  <C extends Console.Console>(console: C) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R, C extends Console.Console>(effect: Effect.Effect<A, E, R>, console: C) => Effect.Effect<A, E, R>
 >(2, (effect, value) =>
   core.fiberRefLocallyWith(
     effect,
@@ -35,14 +35,14 @@ export const withConsole = dual<
   ))
 
 /** @internal */
-export const withConsoleScoped = <A extends Console.Console>(console: A): Effect.Effect<Scope.Scope, never, void> =>
+export const withConsoleScoped = <A extends Console.Console>(console: A): Effect.Effect<void, never, Scope.Scope> =>
   fiberRuntime.fiberRefLocallyScopedWith(
     defaultServices.currentServices,
     Context.add(defaultConsole.consoleTag, console)
   )
 
 /** @internal */
-export const setConsole = <A extends Console.Console>(console: A): Layer.Layer<never, never, never> =>
+export const setConsole = <A extends Console.Console>(console: A): Layer.Layer<never> =>
   layer.scopedDiscard(
     fiberRuntime.fiberRefLocallyScopedWith(
       defaultServices.currentServices,
@@ -122,14 +122,14 @@ export const withGroup = dual<
       readonly label?: string | undefined
       readonly collapsed?: boolean | undefined
     }
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
     options?: {
       readonly label?: string | undefined
       readonly collapsed?: boolean | undefined
     }
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >((args) => core.isEffect(args[0]), (self, options) =>
   consoleWith((_) =>
     core.acquireUseRelease(
@@ -141,8 +141,8 @@ export const withGroup = dual<
 
 /** @internal */
 export const withTime = dual<
-  (label?: string) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, label?: string) => Effect.Effect<R, E, A>
+  (label?: string) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, label?: string) => Effect.Effect<A, E, R>
 >((args) => core.isEffect(args[0]), (self, label) =>
   consoleWith((_) =>
     core.acquireUseRelease(

package/src/internal/context.ts

@@ -1,7 +1,6 @@
 import type * as C from "../Context.js"
 import * as Equal from "../Equal.js"
 import { dual } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type * as O from "../Option.js"
@@ -23,7 +22,7 @@ export const STMTypeId: STM.STMTypeId = Symbol.for(
 ) as STM.STMTypeId
 
 /** @internal */
-export const TagProto: C.Tag<unknown, unknown> = {
+export const TagProto: any = {
   ...EffectPrototype,
   _tag: "Tag",
   _op: "Tag",
@@ -38,7 +37,7 @@ export const TagProto: C.Tag<unknown, unknown> = {
   toJSON<I, A>(this: C.Tag<I, A>) {
     return {
       _id: "Tag",
-      identifier: this.identifier,
+      key: this.key,
       stack: this.stack
     }
   },
@@ -56,13 +55,8 @@ export const TagProto: C.Tag<unknown, unknown> = {
   }
 }
 
-const tagRegistry = globalValue("effect/Context/Tag/tagRegistry", () => new Map<any, C.Tag<any, any>>())
-
 /** @internal */
-export const makeTag = <Identifier, Service = Identifier>(identifier?: unknown): C.Tag<Identifier, Service> => {
-  if (identifier && tagRegistry.has(identifier)) {
-    return tagRegistry.get(identifier)!
-  }
+export const makeGenericTag = <Identifier, Service = Identifier>(key: string): C.Tag<Identifier, Service> => {
   const limit = Error.stackTraceLimit
   Error.stackTraceLimit = 2
   const creationError = new Error()
@@ -73,13 +67,28 @@ export const makeTag = <Identifier, Service = Identifier>(identifier?: unknown):
       return creationError.stack
     }
   })
-  if (identifier) {
-    tag.identifier = identifier
-    tagRegistry.set(identifier, tag)
-  }
+  tag.key = key
   return tag
 }
 
+/** @internal */
+export const Tag = <const Id extends string>(id: Id) => <Self, Shape>(): C.TagClass<Self, Id, Shape> => {
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 2
+  const creationError = new Error()
+  Error.stackTraceLimit = limit
+
+  function TagClass() {}
+  Object.setPrototypeOf(TagClass, TagProto)
+  TagClass.key = id
+  Object.defineProperty(TagClass, "stack", {
+    get() {
+      return creationError.stack
+    }
+  })
+  return TagClass as any
+}
+
 /** @internal */
 export const TypeId: C.TypeId = Symbol.for("effect/Context") as C.TypeId
 
@@ -122,14 +131,14 @@ export const ContextProto: Omit<C.Context<unknown>, "unsafeMap"> = {
 }
 
 /** @internal */
-export const makeContext = <Services>(unsafeMap: Map<C.Tag<any, any>, any>): C.Context<Services> => {
+export const makeContext = <Services>(unsafeMap: Map<string, any>): C.Context<Services> => {
   const context = Object.create(ContextProto)
   context.unsafeMap = unsafeMap
   return context
 }
 
 const serviceNotFoundError = (tag: C.Tag<any, any>) => {
-  const error = new Error(`Service not found${tag.identifier ? `: ${String(tag.identifier)}` : ""}`)
+  const error = new Error(`Service not found${tag.key ? `: ${String(tag.key)}` : ""}`)
   if (tag.stack) {
     const lines = tag.stack.split("\n")
     if (lines.length > 2) {
@@ -162,7 +171,7 @@ export const empty = (): C.Context<never> => _empty
 export const make = <T extends C.Tag<any, any>>(
   tag: T,
   service: C.Tag.Service<T>
-): C.Context<C.Tag.Identifier<T>> => makeContext(new Map([[tag, service]]))
+): C.Context<C.Tag.Identifier<T>> => makeContext(new Map([[tag.key, service]]))
 
 /** @internal */
 export const add = dual<
@@ -179,7 +188,7 @@ export const add = dual<
   ) => C.Context<Services | C.Tag.Identifier<T>>
 >(3, (self, tag, service) => {
   const map = new Map(self.unsafeMap)
-  map.set(tag as C.Tag<unknown, unknown>, service)
+  map.set(tag.key, service)
   return makeContext(map)
 })
 
@@ -188,10 +197,10 @@ export const unsafeGet = dual<
   <S, I>(tag: C.Tag<I, S>) => <Services>(self: C.Context<Services>) => S,
   <Services, S, I>(self: C.Context<Services>, tag: C.Tag<I, S>) => S
 >(2, (self, tag) => {
-  if (!self.unsafeMap.has(tag)) {
+  if (!self.unsafeMap.has(tag.key)) {
     throw serviceNotFoundError(tag as any)
   }
-  return self.unsafeMap.get(tag)! as any
+  return self.unsafeMap.get(tag.key)! as any
 })
 
 /** @internal */
@@ -205,10 +214,10 @@ export const getOption = dual<
   <S, I>(tag: C.Tag<I, S>) => <Services>(self: C.Context<Services>) => O.Option<S>,
   <Services, S, I>(self: C.Context<Services>, tag: C.Tag<I, S>) => O.Option<S>
 >(2, (self, tag) => {
-  if (!self.unsafeMap.has(tag)) {
+  if (!self.unsafeMap.has(tag.key)) {
     return option.none
   }
-  return option.some(self.unsafeMap.get(tag)! as any)
+  return option.some(self.unsafeMap.get(tag.key)! as any)
 })
 
 /** @internal */
@@ -229,7 +238,7 @@ export const pick =
   (self: C.Context<Services>): C.Context<
     { [k in keyof S]: C.Tag.Identifier<S[k]> }[number]
   > => {
-    const tagSet = new Set<unknown>(tags)
+    const tagSet = new Set<string>(tags.map((_) => _.key))
     const newEnv = new Map()
     for (const [tag, s] of self.unsafeMap.entries()) {
       if (tagSet.has(tag)) {
@@ -247,7 +256,7 @@ export const omit =
   > => {
     const newEnv = new Map(self.unsafeMap)
     for (const tag of tags) {
-      newEnv.delete(tag)
+      newEnv.delete(tag.key)
     }
     return makeContext(newEnv)
   }