effect 2.2.5 → 2.3.0

package/src/internal/data.ts

@@ -1,4 +1,3 @@
-import type * as Data from "../Data.js"
 import * as Equal from "../Equal.js"
 import * as Hash from "../Hash.js"
 import type * as Types from "../Types.js"
@@ -22,7 +21,7 @@ export const ArrayProto: Equal.Equal = Object.assign(Object.create(Array.prototy
 export const Structural: new<A>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
-) => Data.Case = (function() {
+) => {} = (function() {
   function Structural(this: any, args: any) {
     if (args) {
       Object.assign(this, args)
@@ -33,5 +32,5 @@ export const Structural: new<A>(
 })()
 
 /** @internal */
-export const struct = <As extends Readonly<Record<string, any>>>(as: As): Data.Data<As> =>
+export const struct = <As extends Readonly<Record<string, any>>>(as: As): As =>
   Object.assign(Object.create(StructuralPrototype), as)

package/src/internal/dataSource.ts

@@ -13,18 +13,18 @@ import { complete } from "./request.js"
 
 /** @internal */
 export const make = <R, A>(
-  runAll: (requests: Array<Array<A>>) => Effect.Effect<R, never, void>
+  runAll: (requests: Array<Array<A>>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
   new core.RequestResolverImpl((requests) => runAll(requests.map((_) => _.map((_) => _.request))))
 
 /** @internal */
 export const makeWithEntry = <R, A>(
-  runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<R, never, void>
+  runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> => new core.RequestResolverImpl((requests) => runAll(requests))
 
 /** @internal */
 export const makeBatched = <R, A extends Request.Request<any, any>>(
-  run: (requests: Array<A>) => Effect.Effect<R, never, void>
+  run: (requests: Array<A>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
   new core.RequestResolverImpl<R, A>(
     (requests) =>
@@ -50,15 +50,15 @@ export const makeBatched = <R, A extends Request.Request<any, any>>(
 /** @internal */
 export const around = dual<
   <R2, A2, R3, _>(
-    before: Effect.Effect<R2, never, A2>,
-    after: (a: A2) => Effect.Effect<R3, never, _>
+    before: Effect.Effect<A2, never, R2>,
+    after: (a: A2) => Effect.Effect<_, never, R3>
   ) => <R, A>(
     self: RequestResolver.RequestResolver<A, R>
   ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
   <R, A, R2, A2, R3, _>(
     self: RequestResolver.RequestResolver<A, R>,
-    before: Effect.Effect<R2, never, A2>,
-    after: (a: A2) => Effect.Effect<R3, never, _>
+    before: Effect.Effect<A2, never, R2>,
+    after: (a: A2) => Effect.Effect<_, never, R3>
   ) => RequestResolver.RequestResolver<A, R | R2 | R3>
 >(3, (self, before, after) =>
   new core.RequestResolverImpl(
@@ -181,7 +181,7 @@ export const eitherWith = dual<
   ))
 
 /** @internal */
-export const fromFunction = <A extends Request.Request<never, any>>(
+export const fromFunction = <A extends Request.Request<any>>(
   f: (request: A) => Request.Request.Success<A>
 ): RequestResolver.RequestResolver<A> =>
   makeBatched((requests: Array<A>) =>
@@ -192,7 +192,7 @@ export const fromFunction = <A extends Request.Request<never, any>>(
   ).identified("FromFunction", f)
 
 /** @internal */
-export const fromFunctionBatched = <A extends Request.Request<never, any>>(
+export const fromFunctionBatched = <A extends Request.Request<any>>(
   f: (chunk: Array<A>) => Iterable<Request.Request.Success<A>>
 ): RequestResolver.RequestResolver<A> =>
   makeBatched((as: Array<A>) =>
@@ -205,7 +205,7 @@ export const fromFunctionBatched = <A extends Request.Request<never, any>>(
 
 /** @internal */
 export const fromEffect = <R, A extends Request.Request<any, any>>(
-  f: (a: A) => Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
+  f: (a: A) => Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
 ): RequestResolver.RequestResolver<A, R> =>
   makeBatched((requests: Array<A>) =>
     Effect.forEach(
@@ -224,8 +224,8 @@ export const fromEffectTagged = <
 <
   Fns extends {
     readonly [Tag in A["_tag"]]: [Extract<A, { readonly _tag: Tag }>] extends [infer Req] ?
-      Req extends Request.Request<infer ReqE, infer ReqA> ?
-        (requests: Array<Req>) => Effect.Effect<any, ReqE, Iterable<ReqA>>
+      Req extends Request.Request<infer ReqA, infer ReqE> ?
+        (requests: Array<Req>) => Effect.Effect<Iterable<ReqA>, ReqE, any>
       : never
       : never
   }
@@ -233,7 +233,7 @@ export const fromEffectTagged = <
   fns: Fns
 ): RequestResolver.RequestResolver<
   A,
-  ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer R, infer _E, infer _A> ? R : never
+  ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
 > =>
   makeBatched<any, A>((requests: Array<A>) => {
     const grouped: Record<string, Array<A>> = {}
@@ -249,7 +249,7 @@ export const fromEffectTagged = <
     return Effect.forEach(
       tags,
       (tag) =>
-        Effect.matchCauseEffect((fns[tag] as any)(grouped[tag]) as Effect.Effect<unknown, unknown, Array<any>>, {
+        Effect.matchCauseEffect((fns[tag] as any)(grouped[tag]) as Effect.Effect<Array<any>, unknown, unknown>, {
           onFailure: (cause) =>
             Effect.forEach(grouped[tag], (req) => complete(req, core.exitFail(cause) as any), { discard: true }),
           onSuccess: (res) =>

package/src/internal/defaultServices/console.ts

@@ -6,7 +6,9 @@ import * as core from "../core.js"
 export const TypeId: Console.TypeId = Symbol.for("effect/Console") as Console.TypeId
 
 /** @internal */
-export const consoleTag: Context.Tag<Console.Console, Console.Console> = Context.Tag<Console.Console>(TypeId)
+export const consoleTag: Context.Tag<Console.Console, Console.Console> = Context.GenericTag<Console.Console>(
+  "effect/Console"
+)
 
 /** @internal */
 export const defaultConsole: Console.Console = {

package/src/internal/defaultServices.ts

@@ -41,25 +41,25 @@ export const currentServices = globalValue(
 // circular with Clock
 
 /** @internal */
-export const sleep = (duration: Duration.DurationInput): Effect.Effect<never, never, void> => {
+export const sleep = (duration: Duration.DurationInput): Effect.Effect<void> => {
   const decodedDuration = Duration.decode(duration)
   return clockWith((clock) => clock.sleep(decodedDuration))
 }
 
 /** @internal */
-export const clockWith = <R, E, A>(f: (clock: Clock.Clock) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+export const clockWith = <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   core.fiberRefGetWith(currentServices, (services) => f(Context.get(services, clock.clockTag)))
 
 /** @internal */
-export const currentTimeMillis: Effect.Effect<never, never, number> = clockWith((clock) => clock.currentTimeMillis)
+export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clock.currentTimeMillis)
 
 /** @internal */
-export const currentTimeNanos: Effect.Effect<never, never, bigint> = clockWith((clock) => clock.currentTimeNanos)
+export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => clock.currentTimeNanos)
 
 /** @internal */
 export const withClock = dual<
-  <A extends Clock.Clock>(value: A) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A extends Clock.Clock>(effect: Effect.Effect<R, E, A>, value: A) => Effect.Effect<R, E, A>
+  <A extends Clock.Clock>(value: A) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A extends Clock.Clock, E, R>(effect: Effect.Effect<A, E, R>, value: A) => Effect.Effect<A, E, R>
 >(2, (effect, value) =>
   core.fiberRefLocallyWith(
     currentServices,
@@ -70,8 +70,8 @@ export const withClock = dual<
 
 /** @internal */
 export const withConfigProvider = dual<
-  (value: ConfigProvider.ConfigProvider) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, value: ConfigProvider.ConfigProvider) => Effect.Effect<R, E, A>
+  (value: ConfigProvider.ConfigProvider) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, value: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
 >(2, (effect, value) =>
   core.fiberRefLocallyWith(
     currentServices,
@@ -79,9 +79,9 @@ export const withConfigProvider = dual<
   )(effect))
 
 /** @internal */
-export const configProviderWith = <R, E, A>(
-  f: (configProvider: ConfigProvider.ConfigProvider) => Effect.Effect<R, E, A>
-): Effect.Effect<R, E, A> =>
+export const configProviderWith = <A, E, R>(
+  f: (configProvider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R> =>
   core.fiberRefGetWith(
     currentServices,
     (services) => f(Context.get(services, configProvider.configProviderTag))
@@ -96,43 +96,43 @@ export const configOrDie = <A>(config: Config.Config<A>) => core.orDie(configPro
 // circular with Random
 
 /** @internal */
-export const randomWith = <R, E, A>(f: (random: Random.Random) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+export const randomWith = <A, E, R>(f: (random: Random.Random) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   core.fiberRefGetWith(
     currentServices,
     (services) => f(Context.get(services, random.randomTag))
   )
 
 /** @internal */
-export const next: Effect.Effect<never, never, number> = randomWith((random) => random.next)
+export const next: Effect.Effect<number> = randomWith((random) => random.next)
 
 /** @internal */
-export const nextInt: Effect.Effect<never, never, number> = randomWith((random) => random.nextInt)
+export const nextInt: Effect.Effect<number> = randomWith((random) => random.nextInt)
 
 /** @internal */
-export const nextBoolean: Effect.Effect<never, never, boolean> = randomWith((random) => random.nextBoolean)
+export const nextBoolean: Effect.Effect<boolean> = randomWith((random) => random.nextBoolean)
 
 /** @internal */
-export const nextRange = (min: number, max: number): Effect.Effect<never, never, number> =>
+export const nextRange = (min: number, max: number): Effect.Effect<number> =>
   randomWith((random) => random.nextRange(min, max))
 
 /** @internal */
-export const nextIntBetween = (min: number, max: number): Effect.Effect<never, never, number> =>
+export const nextIntBetween = (min: number, max: number): Effect.Effect<number> =>
   randomWith((random) => random.nextIntBetween(min, max))
 
 /** @internal */
-export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>> =>
+export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> =>
   randomWith((random) => random.shuffle(elements))
 
 // circular with Tracer
 
 /** @internal */
-export const tracerWith = <R, E, A>(f: (tracer: Tracer.Tracer) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+export const tracerWith = <A, E, R>(f: (tracer: Tracer.Tracer) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   core.fiberRefGetWith(currentServices, (services) => f(Context.get(services, tracer.tracerTag)))
 
 /** @internal */
 export const withTracer = dual<
-  (value: Tracer.Tracer) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, value: Tracer.Tracer) => Effect.Effect<R, E, A>
+  (value: Tracer.Tracer) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, value: Tracer.Tracer) => Effect.Effect<A, E, R>
 >(2, (effect, value) =>
   core.fiberRefLocallyWith(
     currentServices,

package/src/internal/deferred.ts

@@ -19,28 +19,28 @@ export const deferredVariance = {
 }
 
 /** @internal */
-export type State</* in out */ E, /* in out */ A> = Pending<E, A> | Done<E, A>
+export type State</* in out */ A, /* in out */ E> = Pending<A, E> | Done<A, E>
 
 /** @internal */
-export interface Pending<in E, in A> {
+export interface Pending<in A, in E> {
   readonly _tag: "Pending"
-  readonly joiners: Array<(effect: Effect.Effect<never, E, A>) => void>
+  readonly joiners: Array<(effect: Effect.Effect<A, E>) => void>
 }
 
 /** @internal */
-export interface Done<out E, out A> {
+export interface Done<out A, out E> {
   readonly _tag: "Done"
-  readonly effect: Effect.Effect<never, E, A>
+  readonly effect: Effect.Effect<A, E>
 }
 
 /** @internal */
-export const pending = <E, A>(
-  joiners: Array<(effect: Effect.Effect<never, E, A>) => void>
-): State<E, A> => {
+export const pending = <A, E>(
+  joiners: Array<(effect: Effect.Effect<A, E>) => void>
+): State<A, E> => {
   return { _tag: OpCodes.OP_STATE_PENDING, joiners }
 }
 
 /** @internal */
-export const done = <E, A>(effect: Effect.Effect<never, E, A>): State<E, A> => {
+export const done = <A, E>(effect: Effect.Effect<A, E>): State<A, E> => {
   return { _tag: OpCodes.OP_STATE_DONE, effect }
 }

package/src/internal/differ/contextPatch.ts

@@ -1,5 +1,5 @@
 import * as Chunk from "../../Chunk.js"
-import type { Context, Tag } from "../../Context.js"
+import type { Context } from "../../Context.js"
 import type { Differ } from "../../Differ.js"
 import * as Equal from "../../Equal.js"
 import * as Dual from "../../Function.js"
@@ -63,7 +63,7 @@ const makeAndThen = <Input, Output, Output2>(
 /** @internal */
 export interface AddService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env, Env | I> {
   readonly _tag: "AddService"
-  readonly tag: Tag<T, I>
+  readonly key: string
   readonly service: T
 }
 
@@ -72,37 +72,37 @@ const AddServiceProto = Object.assign(Object.create(PatchProto), {
 })
 
 const makeAddService = <Env, I, T>(
-  tag: Tag<T, I>,
+  key: string,
   service: T
 ): Differ.Context.Patch<Env, Env | I> => {
   const o = Object.create(AddServiceProto)
-  o.tag = tag
+  o.key = key
   o.service = service
   return o
 }
 
 /** @internal */
-export interface RemoveService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env, Exclude<Env, I>> {
+export interface RemoveService<in out Env, in out I> extends Differ.Context.Patch<Env, Exclude<Env, I>> {
   readonly _tag: "RemoveService"
-  readonly tag: Tag<T, I>
+  readonly key: string
 }
 
 const RemoveServiceProto = Object.assign(Object.create(PatchProto), {
   _tag: "RemoveService"
 })
 
-const makeRemoveService = <Env, I, T>(
-  tag: Tag<T, I>
+const makeRemoveService = <Env, I>(
+  key: string
 ): Differ.Context.Patch<Env, Exclude<Env, I>> => {
   const o = Object.create(RemoveServiceProto)
-  o.tag = tag
+  o.key = key
   return o
 }
 
 /** @internal */
 export interface UpdateService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env | I, Env | I> {
   readonly _tag: "UpdateService"
-  readonly tag: Tag<T, I>
+  readonly key: string
   update(service: T): T
 }
 
@@ -111,11 +111,11 @@ const UpdateServiceProto = Object.assign(Object.create(PatchProto), {
 })
 
 const makeUpdateService = <Env, I, T>(
-  tag: Tag<T, I>,
+  key: string,
   update: (service: T) => T
 ): Differ.Context.Patch<Env | I, Env | I> => {
   const o = Object.create(UpdateServiceProto)
-  o.tag = tag
+  o.key = key
   o.update = update
   return o
 }
@@ -124,7 +124,7 @@ type Instruction =
   | Empty<any, any>
   | AndThen<any, any, any>
   | AddService<any, any, any>
-  | RemoveService<any, any, any>
+  | RemoveService<any, any>
   | UpdateService<any, any, any>
 
 /** @internal */
@@ -184,7 +184,7 @@ export const patch = Dual.dual<
   let patches: Chunk.Chunk<Differ.Context.Patch<unknown, unknown>> = Chunk.of(
     self as Differ.Context.Patch<unknown, unknown>
   )
-  const updatedContext: Map<Tag<any, any>, unknown> = new Map(context.unsafeMap)
+  const updatedContext: Map<string, unknown> = new Map(context.unsafeMap)
   while (Chunk.isNonEmpty(patches)) {
     const head: Instruction = Chunk.headNonEmpty(patches) as Instruction
     const tail = Chunk.tailNonEmpty(patches)
@@ -194,7 +194,7 @@ export const patch = Dual.dual<
         break
       }
       case "AddService": {
-        updatedContext.set(head.tag, head.service)
+        updatedContext.set(head.key, head.service)
         patches = tail
         break
       }
@@ -203,12 +203,12 @@ export const patch = Dual.dual<
         break
       }
       case "RemoveService": {
-        updatedContext.delete(head.tag)
+        updatedContext.delete(head.key)
         patches = tail
         break
       }
       case "UpdateService": {
-        updatedContext.set(head.tag, head.update(updatedContext.get(head.tag)))
+        updatedContext.set(head.key, head.update(updatedContext.get(head.key)))
         wasServiceUpdated = true
         patches = tail
         break