effect 2.2.5 → 2.3.1

package/src/Clock.ts

@@ -35,7 +35,7 @@ export interface Clock {
   /**
    * Returns the current time in milliseconds.
    */
-  readonly currentTimeMillis: Effect.Effect<never, never, number>
+  readonly currentTimeMillis: Effect.Effect<number>
   /**
    * Unsafely returns the current time in nanoseconds.
    */
@@ -43,11 +43,11 @@ export interface Clock {
   /**
    * Returns the current time in nanoseconds.
    */
-  readonly currentTimeNanos: Effect.Effect<never, never, bigint>
+  readonly currentTimeNanos: Effect.Effect<bigint>
   /**
    * Asynchronously sleeps for the specified duration.
    */
-  sleep(duration: Duration.Duration): Effect.Effect<never, never, void>
+  sleep(duration: Duration.Duration): Effect.Effect<void>
 }
 
 /**
@@ -83,25 +83,25 @@ export const make: (_: void) => Clock = internal.make
  * @since 2.0.0
  * @category constructors
  */
-export const sleep: (duration: Duration.DurationInput) => Effect.Effect<never, never, void> = defaultServices.sleep
+export const sleep: (duration: Duration.DurationInput) => Effect.Effect<void> = defaultServices.sleep
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const currentTimeMillis: Effect.Effect<never, never, number> = defaultServices.currentTimeMillis
+export const currentTimeMillis: Effect.Effect<number> = defaultServices.currentTimeMillis
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const currentTimeNanos: Effect.Effect<never, never, bigint> = defaultServices.currentTimeNanos
+export const currentTimeNanos: Effect.Effect<bigint> = defaultServices.currentTimeNanos
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const clockWith: <R, E, A>(f: (clock: Clock) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, A> =
+export const clockWith: <A, E, R>(f: (clock: Clock) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
   defaultServices.clockWith
 
 /**

package/src/Config.ts

@@ -33,7 +33,7 @@ export type ConfigTypeId = typeof ConfigTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Config<out A> extends Config.Variance<A>, Effect.Effect<never, ConfigError.ConfigError, A> {}
+export interface Config<out A> extends Config.Variance<A>, Effect.Effect<A, ConfigError.ConfigError> {}
 
 /**
  * @since 2.0.0

package/src/ConfigProvider.ts

@@ -46,7 +46,7 @@ export interface ConfigProvider extends ConfigProvider.Proto, Pipeable {
   /**
    * Loads the specified configuration, or fails with a config error.
    */
-  load<A>(config: Config.Config<A>): Effect.Effect<never, ConfigError.ConfigError, A>
+  load<A>(config: Config.Config<A>): Effect.Effect<A, ConfigError.ConfigError>
   /**
    * Flattens this config provider into a simplified config provider that knows
    * only how to deal with flat (key/value) properties.
@@ -81,10 +81,10 @@ export declare namespace ConfigProvider {
       path: ReadonlyArray<string>,
       config: Config.Config.Primitive<A>,
       split?: boolean
-    ): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+    ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     enumerateChildren(
       path: ReadonlyArray<string>
-    ): Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>>
+    ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError>
   }
 
   /**
@@ -146,7 +146,7 @@ export const ConfigProvider: Context.Tag<ConfigProvider, ConfigProvider> = inter
  */
 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.Flat
   }
 ) => ConfigProvider = internal.make
@@ -162,10 +162,10 @@ export const makeFlat: (options: {
     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.Flat = internal.makeFlat
 

package/src/Console.ts

@@ -26,27 +26,27 @@ export type TypeId = typeof TypeId
  */
 export interface Console {
   readonly [TypeId]: TypeId
-  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<never, never, void>
-  readonly clear: Effect<never, never, void>
-  count(label?: string): Effect<never, never, void>
-  countReset(label?: string): Effect<never, never, void>
-  debug(...args: ReadonlyArray<any>): Effect<never, never, void>
-  dir(item: any, options?: any): Effect<never, never, void>
-  dirxml(...args: ReadonlyArray<any>): Effect<never, never, void>
-  error(...args: ReadonlyArray<any>): Effect<never, never, void>
+  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<void>
+  readonly clear: Effect<void>
+  count(label?: string): Effect<void>
+  countReset(label?: string): Effect<void>
+  debug(...args: ReadonlyArray<any>): Effect<void>
+  dir(item: any, options?: any): Effect<void>
+  dirxml(...args: ReadonlyArray<any>): Effect<void>
+  error(...args: ReadonlyArray<any>): Effect<void>
   group(options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }): Effect<never, never, void>
-  readonly groupEnd: Effect<never, never, void>
-  info(...args: ReadonlyArray<any>): Effect<never, never, void>
-  log(...args: ReadonlyArray<any>): Effect<never, never, void>
-  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<never, never, void>
-  time(label?: string): Effect<never, never, void>
-  timeEnd(label?: string): Effect<never, never, void>
-  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<never, never, void>
-  trace(...args: ReadonlyArray<any>): Effect<never, never, void>
-  warn(...args: ReadonlyArray<any>): Effect<never, never, void>
+  }): Effect<void>
+  readonly groupEnd: Effect<void>
+  info(...args: ReadonlyArray<any>): Effect<void>
+  log(...args: ReadonlyArray<any>): Effect<void>
+  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<void>
+  time(label?: string): Effect<void>
+  timeEnd(label?: string): Effect<void>
+  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<void>
+  trace(...args: ReadonlyArray<any>): Effect<void>
+  warn(...args: ReadonlyArray<any>): Effect<void>
   readonly unsafe: UnsafeConsole
 }
 
@@ -89,123 +89,119 @@ export const Console: Context.Tag<Console, Console> = defaultConsole.consoleTag
  * @category default services
  */
 export const withConsole: {
-  <A extends Console>(console: A): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A extends Console>(effect: Effect<R, E, A>, console: A): Effect<R, E, A>
+  <C extends Console>(console: C): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>
+  <A, E, R, C extends Console>(effect: Effect<A, E, R>, console: C): Effect<A, E, R>
 } = internal.withConsole
 
 /**
  * @since 2.0.0
  * @category default services
  */
-export const setConsole: <A extends Console>(console: A) => Layer.Layer<never, never, never> = internal.setConsole
+export const setConsole: <A extends Console>(console: A) => Layer.Layer<never> = internal.setConsole
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const consoleWith: <R, E, A>(f: (console: Console) => Effect<R, E, A>) => Effect<R, E, A> = internal.consoleWith
+export const consoleWith: <A, E, R>(f: (console: Console) => Effect<A, E, R>) => Effect<A, E, R> = internal.consoleWith
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.assert
+export const assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<void> = internal.assert
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const clear: Effect<never, never, void> = internal.clear
+export const clear: Effect<void> = internal.clear
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const count: (label?: string) => Effect<never, never, void> = internal.count
+export const count: (label?: string) => Effect<void> = internal.count
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const countReset: (label?: string) => Effect<never, never, void> = internal.countReset
+export const countReset: (label?: string) => Effect<void> = internal.countReset
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const debug: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.debug
+export const debug: (...args: ReadonlyArray<any>) => Effect<void> = internal.debug
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const dir: (item: any, options?: any) => Effect<never, never, void> = internal.dir
+export const dir: (item: any, options?: any) => Effect<void> = internal.dir
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const dirxml: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.dirxml
+export const dirxml: (...args: ReadonlyArray<any>) => Effect<void> = internal.dirxml
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const error: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.error
+export const error: (...args: ReadonlyArray<any>) => Effect<void> = internal.error
 
 /**
  * @since 2.0.0
  * @category accessor
  */
 export const group: (
-  options?: {
-    label?: string | undefined
-    collapsed?: boolean | undefined
-  }
-) => Effect<Scope, never, void> = internal.group
+  options?: { label?: string | undefined; collapsed?: boolean | undefined } | undefined
+) => Effect<void, never, Scope> = internal.group
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const info: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.info
+export const info: (...args: ReadonlyArray<any>) => Effect<void> = internal.info
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const log: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.log
+export const log: (...args: ReadonlyArray<any>) => Effect<void> = internal.log
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<never, never, void> =
-  internal.table
+export const table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<void> = internal.table
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const time: (label?: string) => Effect<Scope, never, void> = internal.time
+export const time: (label?: string | undefined) => Effect<void, never, Scope> = internal.time
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.timeLog
+export const timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<void> = internal.timeLog
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const trace: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.trace
+export const trace: (...args: ReadonlyArray<any>) => Effect<void> = internal.trace
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const warn: (...args: ReadonlyArray<any>) => Effect<never, never, void> = internal.warn
+export const warn: (...args: ReadonlyArray<any>) => Effect<void> = internal.warn
 
 /**
  * @since 2.0.0
@@ -215,11 +211,11 @@ export const withGroup: {
   (options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(self: Effect<R, E, A>, options?: {
+  }): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
+  <A, E, R>(self: Effect<A, E, R>, options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }): Effect<R, E, A>
+  }): Effect<A, E, R>
 } = internal.withGroup
 
 /**
@@ -227,6 +223,6 @@ export const withGroup: {
  * @category accessor
  */
 export const withTime: {
-  (label?: string): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(self: Effect<R, E, A>, label?: string): Effect<R, E, A>
+  (label?: string): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
+  <A, E, R>(self: Effect<A, E, R>, label?: string): Effect<A, E, R>
 } = internal.withTime

package/src/Context.ts

@@ -37,12 +37,31 @@ export interface Tag<in out Identifier, in out Service> extends Pipeable, Inspec
   of(self: Service): Service
   context(self: Service): Context<Identifier>
   readonly stack?: string | undefined
-  readonly identifier?: unknown
+  readonly key: string
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: TagUnify<this>
   [Unify.ignoreSymbol]?: TagUnifyIgnore
 }
 
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface TagClassShape<Id, Shape> {
+  readonly [TagTypeId]: {
+    readonly Id: Id
+    readonly Shape: Shape
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface TagClass<Self, Id, Shape> extends Tag<Self, Shape> {
+  new(_: never): TagClassShape<Id, Shape>
+}
+
 /**
  * @category models
  * @since 2.0.0
@@ -64,35 +83,32 @@ export declare namespace Tag {
   /**
    * @since 2.0.0
    */
-  export type Service<T extends Tag<any, any>> = T extends Tag<any, infer A> ? A : never
+  export type Service<T extends Tag<any, any> | TagClassShape<any, any>> = T extends Tag<any, infer A> ? A
+    : T extends TagClassShape<any, infer A> ? A
+    : never
   /**
    * @since 2.0.0
    */
-  export type Identifier<T extends Tag<any, any>> = T extends Tag<infer A, any> ? A : never
+  export type Identifier<T extends Tag<any, any> | TagClassShape<any, any>> = T extends Tag<infer A, any> ? A
+    : T extends TagClassShape<infer A, any> ? A
+    : never
 }
 
 /**
  * Creates a new `Tag` instance with an optional key parameter.
  *
- * Specifying the `key` will make the `Tag` global, meaning two tags with the same
- * key will map to the same instance.
- *
- * Note: this is useful for cases where live reload can happen and it is
- * desireable to preserve the instance across reloads.
- *
- * @param key - An optional key that makes the `Tag` global.
+ * @param key - A key that will be used to compare tags.
  *
  * @example
  * import * as Context from "effect/Context"
  *
- * assert.strictEqual(Context.Tag() === Context.Tag(), false)
- * assert.strictEqual(Context.Tag("PORT") === Context.Tag("PORT"), true)
+ * assert.strictEqual(Context.GenericTag("PORT").key === Context.GenericTag("PORT").key, true)
  *
  * @since 2.0.0
  * @category constructors
  */
-export const Tag: <Identifier, Service = Identifier>(identifier?: unknown) => Tag<Identifier, Service> =
-  internal.makeTag
+export const GenericTag: <Identifier, Service = Identifier>(key: string) => Tag<Identifier, Service> =
+  internal.makeGenericTag
 
 const TypeId: unique symbol = internal.TypeId as TypeId
 
@@ -116,14 +132,14 @@ export interface Context<in Services> extends Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
     readonly _Services: Types.Contravariant<Services>
   }
-  readonly unsafeMap: Map<Tag<any, any>, any>
+  readonly unsafeMap: Map<string, any>
 }
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const unsafeMake: <Services>(unsafeMap: Map<Tag<any, any>, any>) => Context<Services> = internal.makeContext
+export const unsafeMake: <Services>(unsafeMap: Map<string, any>) => Context<Services> = internal.makeContext
 
 /**
  * Checks if the provided argument is a `Context`.
@@ -148,7 +164,7 @@ export const isContext: (input: unknown) => input is Context<never> = internal.i
  * @example
  * import * as Context from "effect/Context"
  *
- * assert.strictEqual(Context.isTag(Context.Tag()), true)
+ * assert.strictEqual(Context.isTag(Context.GenericTag("Tag")), true)
  *
  * @since 2.0.0
  * @category guards
@@ -174,7 +190,7 @@ export const empty: () => Context<never> = internal.empty
  * @example
  * import * as Context from "effect/Context"
  *
- * const Port = Context.Tag<{ PORT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
  *
  * const Services = Context.make(Port, { PORT: 8080 })
  *
@@ -193,8 +209,8 @@ export const make: <T extends Tag<any, any>>(tag: T, service: Tag.Service<T>) =>
  * import * as Context from "effect/Context"
  * import { pipe } from "effect/Function"
  *
- * const Port = Context.Tag<{ PORT: number }>()
- * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
+ * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout")
  *
  * const someContext = Context.make(Port, { PORT: 8080 })
  *
@@ -230,8 +246,8 @@ export const add: {
  * import * as Context from "effect/Context"
  * import { pipe } from "effect/Function"
  *
- * const Port = Context.Tag<{ PORT: number }>()
- * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
+ * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout")
  *
  * const Services = pipe(
  *   Context.make(Port, { PORT: 8080 }),
@@ -260,8 +276,8 @@ export const get: {
  * @example
  * import * as Context from "effect/Context"
  *
- * const Port = Context.Tag<{ PORT: number }>()
- * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
+ * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout")
  *
  * const Services = Context.make(Port, { PORT: 8080 })
  *
@@ -287,8 +303,8 @@ export const unsafeGet: {
  * import * as Context from "effect/Context"
  * import * as O from "effect/Option"
  *
- * const Port = Context.Tag<{ PORT: number }>()
- * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
+ * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout")
  *
  * const Services = Context.make(Port, { PORT: 8080 })
  *
@@ -312,8 +328,8 @@ export const getOption: {
  * @example
  * import * as Context from "effect/Context"
  *
- * const Port = Context.Tag<{ PORT: number }>()
- * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
+ * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout")
  *
  * const firstContext = Context.make(Port, { PORT: 8080 })
  * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })
@@ -341,8 +357,8 @@ export const merge: {
  * import { pipe } from "effect/Function"
  * import * as O from "effect/Option"
  *
- * const Port = Context.Tag<{ PORT: number }>()
- * const Timeout = Context.Tag<{ TIMEOUT: number }>()
+ * const Port = Context.GenericTag<{ PORT: number }>("Port")
+ * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout")
  *
  * const someContext = pipe(
  *   Context.make(Port, { PORT: 8080 }),
@@ -367,3 +383,9 @@ export const omit: <Services, S extends Array<ValidTagsById<Services>>>(
   ...tags: S
 ) => (self: Context<Services>) => Context<Exclude<Services, { [k in keyof S]: Tag.Identifier<S[k]> }[keyof S]>> =
   internal.omit
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Tag: <const Id extends string>(id: Id) => <Self, Shape>() => TagClass<Self, Id, Shape> = internal.Tag