effect 2.2.5 → 2.3.1

package/src/internal/reloadable.ts

@@ -1,7 +1,6 @@
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
 import { pipe } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
 import type * as Layer from "../Layer.js"
 import type * as Reloadable from "../Reloadable.js"
 import type * as Schedule from "../Schedule.js"
@@ -29,14 +28,10 @@ const reloadableVariance = {
 export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
   tag: Out,
   options: {
-    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
     readonly schedule: Schedule.Schedule<R, unknown, unknown>
   }
-): Layer.Layer<
-  R | In,
-  E,
-  Reloadable.Reloadable<Context.Tag.Identifier<Out>>
-> =>
+): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
   _layer.scoped(
     reloadableTag(tag),
     pipe(
@@ -60,14 +55,10 @@ export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
 export const autoFromConfig = <Out extends Context.Tag<any, any>, In, E, R>(
   tag: Out,
   options: {
-    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
     readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
   }
-): Layer.Layer<
-  R | In,
-  E,
-  Reloadable.Reloadable<Context.Tag.Identifier<Out>>
-> =>
+): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
   _layer.scoped(
     reloadableTag(tag),
     pipe(
@@ -87,7 +78,7 @@ export const autoFromConfig = <Out extends Context.Tag<any, any>, In, E, R>(
 /** @internal */
 export const get = <T extends Context.Tag<any, any>>(
   tag: T
-): Effect.Effect<Reloadable.Reloadable<Context.Tag.Identifier<T>>, never, Context.Tag.Service<T>> =>
+): Effect.Effect<Context.Tag.Service<T>, never, Reloadable.Reloadable<Context.Tag.Identifier<T>>> =>
   core.flatMap(
     reloadableTag(tag),
     (reloadable) => scopedRef.get(reloadable.scopedRef)
@@ -97,9 +88,9 @@ export const get = <T extends Context.Tag<any, any>>(
 export const manual = <Out extends Context.Tag<any, any>, In, E>(
   tag: Out,
   options: {
-    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
   }
-): Layer.Layer<In, E, Reloadable.Reloadable<Context.Tag.Identifier<Out>>> =>
+): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, In> =>
   _layer.scoped(
     reloadableTag(tag),
     pipe(
@@ -120,31 +111,20 @@ export const manual = <Out extends Context.Tag<any, any>, In, E>(
     )
   )
 
-/** @internal */
-const tagMap = globalValue(
-  Symbol.for("effect/Reloadable/tagMap"),
-  () => new WeakMap<Context.Tag<any, any>, Context.Tag<any, any>>([])
-)
-
 /** @internal */
 export const reloadableTag = <T extends Context.Tag<any, any>>(
   tag: T
 ): Context.Tag<Reloadable.Reloadable<Context.Tag.Identifier<T>>, Reloadable.Reloadable<Context.Tag.Service<T>>> => {
-  if (tagMap.has(tag)) {
-    return tagMap.get(tag)!
-  }
-  const newTag = Context.Tag<
+  return Context.GenericTag<
     Reloadable.Reloadable<Context.Tag.Identifier<T>>,
     Reloadable.Reloadable<Context.Tag.Service<T>>
-  >()
-  tagMap.set(tag, newTag)
-  return newTag
+  >(`effect/Reloadable<${tag.key}>`)
 }
 
 /** @internal */
 export const reload = <T extends Context.Tag<any, any>>(
   tag: T
-): Effect.Effect<Reloadable.Reloadable<Context.Tag.Identifier<T>>, unknown, void> =>
+): Effect.Effect<void, unknown, Reloadable.Reloadable<Context.Tag.Identifier<T>>> =>
   core.flatMap(
     reloadableTag(tag),
     (reloadable) => reloadable.reload
@@ -153,7 +133,7 @@ export const reload = <T extends Context.Tag<any, any>>(
 /** @internal */
 export const reloadFork = <T extends Context.Tag<any, any>>(
   tag: T
-): Effect.Effect<Reloadable.Reloadable<Context.Tag.Identifier<T>>, unknown, void> =>
+): Effect.Effect<void, unknown, Reloadable.Reloadable<Context.Tag.Identifier<T>>> =>
   core.flatMap(reloadableTag(tag), (reloadable) =>
     pipe(
       reloadable.reload,

package/src/internal/request.ts

@@ -49,7 +49,7 @@ export const tagged = <R extends Request.Request<any, any> & { _tag: string }>(
 export const Class: new<Error, Success, A extends Record<string, any>>(
   args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
-) => Request.Request<Error, Success> & Readonly<A> = (function() {
+) => Request.Request<Success, Error> & Readonly<A> = (function() {
   function Class(this: any, args: any) {
     if (args) {
       Object.assign(this, args)
@@ -65,7 +65,7 @@ export const TaggedClass = <Tag extends string>(
 ): new<Error, Success, A extends Record<string, any>>(
   args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
-) => Request.Request<Error, Success> & Readonly<A> & { readonly _tag: Tag } => {
+) => Request.Request<Success, Error> & Readonly<A> & { readonly _tag: Tag } => {
   return class TaggedClass extends Class<any, any, any> {
     readonly _tag = tag
   } as any
@@ -75,11 +75,11 @@ export const TaggedClass = <Tag extends string>(
 export const complete = dual<
   <A extends Request.Request<any, any>>(
     result: Request.Request.Result<A>
-  ) => (self: A) => Effect.Effect<never, never, void>,
+  ) => (self: A) => Effect.Effect<void>,
   <A extends Request.Request<any, any>>(
     self: A,
     result: Request.Request.Result<A>
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 >(2, (self, result) =>
   core.fiberRefGetWith(
     completedRequestMap.currentRequestMap,
@@ -98,12 +98,12 @@ export const complete = dual<
 /** @internal */
 export const completeEffect = dual<
   <A extends Request.Request<any, any>, R>(
-    effect: Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
-  ) => (self: A) => Effect.Effect<R, never, void>,
+    effect: Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
+  ) => (self: A) => Effect.Effect<void, never, R>,
   <A extends Request.Request<any, any>, R>(
     self: A,
-    effect: Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
-  ) => Effect.Effect<R, never, void>
+    effect: Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
+  ) => Effect.Effect<void, never, R>
 >(2, (self, effect) =>
   core.matchEffect(effect, {
     onFailure: (error) => complete(self, core.exitFail(error) as any),
@@ -114,33 +114,33 @@ export const completeEffect = dual<
 export const fail = dual<
   <A extends Request.Request<any, any>>(
     error: Request.Request.Error<A>
-  ) => (self: A) => Effect.Effect<never, never, void>,
+  ) => (self: A) => Effect.Effect<void>,
   <A extends Request.Request<any, any>>(
     self: A,
     error: Request.Request.Error<A>
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 >(2, (self, error) => complete(self, core.exitFail(error) as any))
 
 /** @internal */
 export const failCause = dual<
   <A extends Request.Request<any, any>>(
     cause: Cause.Cause<Request.Request.Error<A>>
-  ) => (self: A) => Effect.Effect<never, never, void>,
+  ) => (self: A) => Effect.Effect<void>,
   <A extends Request.Request<any, any>>(
     self: A,
     cause: Cause.Cause<Request.Request.Error<A>>
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 >(2, (self, cause) => complete(self, core.exitFailCause(cause) as any))
 
 /** @internal */
 export const succeed = dual<
   <A extends Request.Request<any, any>>(
     value: Request.Request.Success<A>
-  ) => (self: A) => Effect.Effect<never, never, void>,
+  ) => (self: A) => Effect.Effect<void>,
   <A extends Request.Request<any, any>>(
     self: A,
     value: Request.Request.Success<A>
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 >(2, (self, value) => complete(self, core.exitSucceed(value) as any))
 
 /** @internal */

package/src/internal/resource.ts

@@ -24,10 +24,10 @@ const resourceVariance = {
 }
 
 /** @internal */
-export const auto = <R, E, A, R2, Out>(
-  acquire: Effect.Effect<R, E, A>,
+export const auto = <A, E, R, R2, Out>(
+  acquire: Effect.Effect<A, E, R>,
   policy: Schedule.Schedule<R2, unknown, Out>
-): Effect.Effect<R | R2 | Scope.Scope, never, Resource.Resource<E, A>> =>
+): Effect.Effect<Resource.Resource<A, E>, never, R | R2 | Scope.Scope> =>
   core.tap(manual(acquire), (manual) =>
     fiberRuntime.acquireRelease(
       pipe(
@@ -40,9 +40,9 @@ export const auto = <R, E, A, R2, Out>(
     ))
 
 /** @internal */
-export const manual = <R, E, A>(
-  acquire: Effect.Effect<R, E, A>
-): Effect.Effect<R | Scope.Scope, never, Resource.Resource<E, A>> =>
+export const manual = <A, E, R>(
+  acquire: Effect.Effect<A, E, R>
+): Effect.Effect<Resource.Resource<A, E>, never, R | Scope.Scope> =>
   core.flatMap(core.context<R>(), (env) =>
     pipe(
       scopedRef.fromAcquire(core.exit(acquire)),
@@ -54,11 +54,11 @@ export const manual = <R, E, A>(
     ))
 
 /** @internal */
-export const get = <E, A>(self: Resource.Resource<E, A>): Effect.Effect<never, E, A> =>
+export const get = <A, E>(self: Resource.Resource<A, E>): Effect.Effect<A, E> =>
   core.flatMap(scopedRef.get(self.scopedRef), identity)
 
 /** @internal */
-export const refresh = <E, A>(self: Resource.Resource<E, A>): Effect.Effect<never, E, void> =>
+export const refresh = <A, E>(self: Resource.Resource<A, E>): Effect.Effect<void, E> =>
   scopedRef.set(
     self.scopedRef,
     core.map(self.acquire, core.exitSucceed)

package/src/internal/runtime.ts

@@ -28,10 +28,10 @@ import * as _supervisor from "./supervisor.js"
 
 /** @internal */
 export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
-<E, A>(
-  self: Effect.Effect<R, E, A>,
+<A, E>(
+  self: Effect.Effect<A, E, R>,
   options?: Runtime.RunForkOptions
-): Fiber.RuntimeFiber<E, A> => {
+): Fiber.RuntimeFiber<A, E> => {
   const fiberId = FiberId.unsafeMake()
   const fiberRefUpdates: ReadonlyArray.NonEmptyArray<
     readonly [FiberRef.FiberRef<any>, ReadonlyArray.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
@@ -50,13 +50,13 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
     fiberRefs = options.updateRefs(fiberRefs, fiberId)
   }
 
-  const fiberRuntime: FiberRuntime.FiberRuntime<E, A> = new FiberRuntime.FiberRuntime<E, A>(
+  const fiberRuntime: FiberRuntime.FiberRuntime<A, E> = new FiberRuntime.FiberRuntime<A, E>(
     fiberId,
     fiberRefs,
     runtime.runtimeFlags
   )
 
-  let effect: Effect.Effect<R, E, A> = self
+  let effect: Effect.Effect<A, E, R> = self
 
   if (options?.scope) {
     effect = core.flatMap(
@@ -97,10 +97,10 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
 
 /** @internal */
 export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
-<E, A>(
-  effect: Effect.Effect<R, E, A>,
-  options: Runtime.RunCallbackOptions<E, A> = {}
-): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<E, A> | undefined) => void => {
+<A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options: Runtime.RunCallbackOptions<A, E> = {}
+): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<A, E> | undefined) => void => {
   const fiberRuntime = unsafeFork(runtime)(effect, options)
 
   if (options.onExit) {
@@ -122,7 +122,7 @@ export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
 }
 
 /** @internal */
-export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): A => {
+export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): A => {
   const result = unsafeRunSyncExit(runtime)(effect)
   if (result._tag === "Failure") {
     throw fiberFailure(result.i0)
@@ -131,8 +131,7 @@ export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect:
   }
 }
 
-/** @internal */
-const asyncFiberException = <E, A>(fiber: Fiber.RuntimeFiber<E, A>): Runtime.AsyncFiberException<E, A> => {
+const asyncFiberException = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Runtime.AsyncFiberException<A, E> => {
   const limit = Error.stackTraceLimit
   Error.stackTraceLimit = 0
   const error = (new Error()) as any
@@ -215,7 +214,7 @@ export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure =>
 /** @internal */
 export const isFiberFailure = (u: unknown): u is Runtime.FiberFailure => Predicate.hasProperty(u, FiberFailureId)
 
-const fastPath = <R, E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> | undefined => {
+const fastPath = <A, E, R>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E> | undefined => {
   const op = effect as core.Primitive
   switch (op._op) {
     case "Failure":
@@ -241,7 +240,7 @@ const fastPath = <R, E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> | un
 
 /** @internal */
 export const unsafeRunSyncExit =
-  <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> => {
+  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E> => {
     const op = fastPath(effect)
     if (op) {
       return op
@@ -258,7 +257,7 @@ export const unsafeRunSyncExit =
 
 /** @internal */
 export const unsafeRunPromise =
-  <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): Promise<A> =>
+  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Promise<A> =>
     unsafeRunPromiseExit(runtime)(effect).then((result) => {
       switch (result._tag) {
         case OpCodes.OP_SUCCESS: {
@@ -272,7 +271,7 @@ export const unsafeRunPromise =
 
 /** @internal */
 export const unsafeRunPromiseExit =
-  <R>(runtime: Runtime.Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>): Promise<Exit.Exit<E, A>> =>
+  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Promise<Exit.Exit<A, E>> =>
     new Promise((resolve) => {
       const op = fastPath(effect)
       if (op) {
@@ -306,8 +305,8 @@ export const make = <R>(
 ): Runtime.Runtime<R> => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs)
 
 /** @internal */
-export const runtime = <R>(): Effect.Effect<R, never, Runtime.Runtime<R>> =>
-  core.withFiberRuntime<R, never, RuntimeImpl<R>>((state, status) =>
+export const runtime = <R>(): Effect.Effect<Runtime.Runtime<R>, never, R> =>
+  core.withFiberRuntime((state, status) =>
     core.succeed(
       new RuntimeImpl<R>(
         state.getFiberRef(core.currentContext as unknown as FiberRef.FiberRef<Context.Context<R>>),
@@ -410,11 +409,11 @@ export const unsafeRunSyncExitEffect = unsafeRunSyncExit(defaultRuntime)
 // circular with Effect
 
 /** @internal */
-export const asyncEffect = <R, E, A, R2, E2, X>(
-  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Effect.Effect<R2, E2, X>
-): Effect.Effect<R | R2, E | E2, A> =>
+export const asyncEffect = <A, E, R, X, E2, R2>(
+  register: (callback: (_: Effect.Effect<A, E, R>) => void) => Effect.Effect<X, E2, R2>
+): Effect.Effect<A, E | E2, R | R2> =>
   core.flatMap(
-    core.deferredMake<E | E2, A>(),
+    core.deferredMake<A, E | E2>(),
     (deferred) =>
       core.flatMap(runtime<R | R2>(), (runtime) =>
         core.uninterruptibleMask((restore) =>