effect 2.2.5 → 2.3.1

package/src/RequestResolver.ts

@@ -55,7 +55,7 @@ export interface RequestResolver<in A, out R = never> extends RequestResolver.Va
    * of requests that must be performed sequentially. The inner `Chunk`
    * represents a batch of requests that can be performed in parallel.
    */
-  runAll(requests: Array<Array<Request.Entry<A>>>): Effect.Effect<R, never, void>
+  runAll(requests: Array<Array<Request.Entry<A>>>): Effect.Effect<void, never, R>
 
   /**
    * Identify the data source using the specific identifier
@@ -95,9 +95,9 @@ export const contextFromServices =
   <R, A extends Request.Request<any, any>>(
     self: RequestResolver<A, R>
   ): Effect.Effect<
-    { [k in keyof Services]: Effect.Effect.Context<Services[k]> }[number],
+    RequestResolver<A, Exclude<R, { [k in keyof Services]: Effect.Effect.Context<Services[k]> }[number]>>,
     never,
-    RequestResolver<A, Exclude<R, { [k in keyof Services]: Effect.Effect.Context<Services[k]> }[number]>>
+    { [k in keyof Services]: Effect.Effect.Context<Services[k]> }[number]
   > => Effect.contextWith((_) => provideContext(self as any, Context.pick(...services)(_ as any)))
 
 /**
@@ -116,7 +116,7 @@ export const isRequestResolver: (u: unknown) => u is RequestResolver<unknown, un
  * @category constructors
  */
 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<A, R> = internal.make
 
 /**
@@ -127,7 +127,7 @@ export const make: <R, A>(
  * @category constructors
  */
 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<A, R> = internal.makeWithEntry
 
 /**
@@ -138,7 +138,7 @@ export const makeWithEntry: <R, A>(
  * @category constructors
  */
 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<A, R> = internal.makeBatched
 
 /**
@@ -150,13 +150,13 @@ export const makeBatched: <R, A extends Request.Request<any, any>>(
  */
 export const around: {
   <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<A, R>) => RequestResolver<A, R2 | R3 | R>
   <R, A, R2, A2, R3, _>(
     self: 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<A, R | R2 | R3>
 } = internal.around
 
@@ -219,9 +219,9 @@ export const eitherWith: {
  * @since 2.0.0
  * @category constructors
  */
-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<A, never> = internal.fromFunction
+) => RequestResolver<A> = internal.fromFunction
 
 /**
  * Constructs a data source from a pure function that takes a list of requests
@@ -231,9 +231,9 @@ export const fromFunction: <A extends Request.Request<never, any>>(
  * @since 2.0.0
  * @category constructors
  */
-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<A, never> = internal.fromFunctionBatched
+) => RequestResolver<A> = internal.fromFunctionBatched
 
 /**
  * Constructs a data source from an effectual function.
@@ -242,7 +242,7 @@ export const fromFunctionBatched: <A extends Request.Request<never, any>>(
  * @category constructors
  */
 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<A, R> = internal.fromEffect
 
 /**
@@ -257,14 +257,14 @@ export const fromEffect: <R, A extends Request.Request<any, any>>(
 export const fromEffectTagged: <A extends Request.Request<any, any> & { readonly _tag: string }>() => <
   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
   }
 >(
   fns: Fns
-) => RequestResolver<A, ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer R, infer _E, infer _A> ? R : never> =
+) => RequestResolver<A, ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer _A, infer _E, infer R> ? R : never> =
   internal.fromEffectTagged
 
 /**
@@ -273,7 +273,7 @@ export const fromEffectTagged: <A extends Request.Request<any, any> & { readonly
  * @since 2.0.0
  * @category constructors
  */
-export const never: RequestResolver<never, never> = internal.never
+export const never: RequestResolver<never> = internal.never
 
 /**
  * Provides this data source with its required context.
@@ -284,11 +284,11 @@ export const never: RequestResolver<never, never> = internal.never
 export const provideContext: {
   <R>(
     context: Context.Context<R>
-  ): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A, never>
+  ): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A>
   <R, A extends Request.Request<any, any>>(
     self: RequestResolver<A, R>,
     context: Context.Context<R>
-  ): RequestResolver<A, never>
+  ): RequestResolver<A>
 } = internal.provideContext
 
 /**

package/src/Resource.ts

@@ -28,11 +28,11 @@ export type ResourceTypeId = typeof ResourceTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Resource<in out E, in out A> extends Resource.Variance<E, A> {
+export interface Resource<in out A, in out E = never> extends Resource.Variance<A, E> {
   /** @internal */
-  readonly scopedRef: ScopedRef.ScopedRef<Exit.Exit<E, A>>
+  readonly scopedRef: ScopedRef.ScopedRef<Exit.Exit<A, E>>
   /** @internal */
-  readonly acquire: Effect.Effect<Scope.Scope, E, A>
+  readonly acquire: Effect.Effect<A, E, Scope.Scope>
 }
 
 /**
@@ -43,10 +43,10 @@ export declare namespace Resource {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in out E, in out A> {
+  export interface Variance<in out A, in out E> {
     readonly [ResourceTypeId]: {
-      _E: Types.Invariant<E>
       _A: Types.Invariant<A>
+      _E: Types.Invariant<E>
     }
   }
 }
@@ -61,10 +61,10 @@ export declare namespace Resource {
  * @since 2.0.0
  * @category constructors
  */
-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<Scope.Scope | R | R2, never, Resource<E, A>> = internal.auto
+) => Effect.Effect<Resource<A, E>, never, Scope.Scope | R | R2> = internal.auto
 
 /**
  * Retrieves the current value stored in the cache.
@@ -72,7 +72,7 @@ export const auto: <R, E, A, R2, Out>(
  * @since 2.0.0
  * @category getters
  */
-export const get: <E, A>(self: Resource<E, A>) => Effect.Effect<never, E, A> = internal.get
+export const get: <A, E>(self: Resource<A, E>) => Effect.Effect<A, E> = internal.get
 
 /**
  * Creates a new `Resource` value that must be manually refreshed by calling
@@ -84,9 +84,9 @@ export const get: <E, A>(self: Resource<E, A>) => Effect.Effect<never, E, A> = i
  * @since 2.0.0
  * @category constructors
  */
-export const manual: <R, E, A>(
-  acquire: Effect.Effect<R, E, A>
-) => Effect.Effect<Scope.Scope | R, never, Resource<E, A>> = internal.manual
+export const manual: <A, E, R>(
+  acquire: Effect.Effect<A, E, R>
+) => Effect.Effect<Resource<A, E>, never, Scope.Scope | R> = internal.manual
 
 /**
  * Refreshes the cache. This method will not return until either the refresh
@@ -95,4 +95,4 @@ export const manual: <R, E, A>(
  * @since 2.0.0
  * @category utils
  */
-export const refresh: <E, A>(self: Resource<E, A>) => Effect.Effect<never, E, void> = internal.refresh
+export const refresh: <A, E>(self: Resource<A, E>) => Effect.Effect<void, E> = internal.refresh

package/src/Runtime.ts

@@ -19,17 +19,17 @@ import type { Scope } from "./Scope.js"
  * @since 2.0.0
  * @category models
  */
-export interface AsyncFiberException<out E, out A> {
+export interface AsyncFiberException<out A, out E = never> {
   readonly _tag: "AsyncFiberException"
-  readonly fiber: Fiber.RuntimeFiber<E, A>
+  readonly fiber: Fiber.RuntimeFiber<A, E>
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Cancel<out E, out A> {
-  (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<E, A> | undefined): void
+export interface Cancel<out A, out E = never> {
+  (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<A, E> | undefined): void
 }
 
 /**
@@ -71,7 +71,7 @@ export interface RunForkOptions {
  */
 export const runFork: <R>(
   runtime: Runtime<R>
-) => <E, A>(self: Effect.Effect<R, E, A>, options?: RunForkOptions) => Fiber.RuntimeFiber<E, A> = internal.unsafeFork
+) => <A, E>(self: Effect.Effect<A, E, R>, options?: RunForkOptions) => Fiber.RuntimeFiber<A, E> = internal.unsafeFork
 
 /**
  * Executes the effect synchronously returning the exit.
@@ -82,7 +82,7 @@ export const runFork: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runSyncExit: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>) => Exit.Exit<E, A> =
+export const runSyncExit: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, E> =
   internal.unsafeRunSyncExit
 
 /**
@@ -94,14 +94,14 @@ export const runSyncExit: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effe
  * @since 2.0.0
  * @category execution
  */
-export const runSync: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>) => A = internal.unsafeRunSync
+export const runSync: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => A = internal.unsafeRunSync
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface RunCallbackOptions<E, A> extends RunForkOptions {
-  readonly onExit?: ((exit: Exit.Exit<E, A>) => void) | undefined
+export interface RunCallbackOptions<in A, in E = never> extends RunForkOptions {
+  readonly onExit?: ((exit: Exit.Exit<A, E>) => void) | undefined
 }
 
 /**
@@ -116,10 +116,10 @@ export interface RunCallbackOptions<E, A> extends RunForkOptions {
  */
 export const runCallback: <R>(
   runtime: Runtime<R>
-) => <E, A>(
-  effect: Effect.Effect<R, E, A>,
-  options?: RunCallbackOptions<E, A> | undefined
-) => (fiberId?: FiberId.FiberId | undefined, options?: RunCallbackOptions<E, A> | undefined) => void =
+) => <A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: RunCallbackOptions<A, E> | undefined
+) => (fiberId?: FiberId.FiberId | undefined, options?: RunCallbackOptions<A, E> | undefined) => void =
   internal.unsafeRunCallback
 
 /**
@@ -133,7 +133,7 @@ export const runCallback: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>) => Promise<A> =
+export const runPromise: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A> =
   internal.unsafeRunPromise
 
 /**
@@ -148,7 +148,7 @@ export const runPromise: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effec
  */
 export const runPromiseExit: <R>(
   runtime: Runtime<R>
-) => <E, A>(effect: Effect.Effect<R, E, A>) => Promise<Exit.Exit<E, A>> = internal.unsafeRunPromiseExit
+) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
 
 /**
  * @since 2.0.0
@@ -267,10 +267,7 @@ export const updateContext: {
  * @example
  * import { Context, Runtime } from "effect"
  *
- * interface Name {
- *   readonly _: unique symbol
- * }
- * const Name = Context.Tag<Name, string>("Name")
+ * class Name extends Context.Tag("Name")<Name, string>() {}
  *
  * const runtime: Runtime.Runtime<Name> = Runtime.defaultRuntime.pipe(
  *   Runtime.provideService(Name, "John")

package/src/RuntimeFlags.ts

@@ -146,31 +146,31 @@ export const disableAll: {
  * @since 2.0.0
  * @category context
  */
-export const disableCooperativeYielding: Layer.Layer<never, never, never> = circular.disableCooperativeYielding
+export const disableCooperativeYielding: Layer.Layer<never> = circular.disableCooperativeYielding
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const disableInterruption: Layer.Layer<never, never, never> = circular.disableInterruption
+export const disableInterruption: Layer.Layer<never> = circular.disableInterruption
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const disableOpSupervision: Layer.Layer<never, never, never> = circular.disableOpSupervision
+export const disableOpSupervision: Layer.Layer<never> = circular.disableOpSupervision
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const disableRuntimeMetrics: Layer.Layer<never, never, never> = circular.disableRuntimeMetrics
+export const disableRuntimeMetrics: Layer.Layer<never> = circular.disableRuntimeMetrics
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const disableWindDown: Layer.Layer<never, never, never> = circular.disableWindDown
+export const disableWindDown: Layer.Layer<never> = circular.disableWindDown
 
 /**
  * Enables the specified `RuntimeFlag`.
@@ -198,31 +198,31 @@ export const enableAll: {
  * @since 2.0.0
  * @category context
  */
-export const enableCooperativeYielding: Layer.Layer<never, never, never> = circular.enableCooperativeYielding
+export const enableCooperativeYielding: Layer.Layer<never> = circular.enableCooperativeYielding
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const enableInterruption: Layer.Layer<never, never, never> = circular.enableInterruption
+export const enableInterruption: Layer.Layer<never> = circular.enableInterruption
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const enableOpSupervision: Layer.Layer<never, never, never> = circular.enableOpSupervision
+export const enableOpSupervision: Layer.Layer<never> = circular.enableOpSupervision
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const enableRuntimeMetrics: Layer.Layer<never, never, never> = circular.enableRuntimeMetrics
+export const enableRuntimeMetrics: Layer.Layer<never> = circular.enableRuntimeMetrics
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const enableWindDown: Layer.Layer<never, never, never> = circular.enableWindDown
+export const enableWindDown: Layer.Layer<never> = circular.enableWindDown
 
 /**
  * Returns true only if the `Interruption` flag is **enabled** and the