effect 2.2.5 → 2.3.1

package/src/Schedule.ts

@@ -81,7 +81,7 @@ export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env
     now: number,
     input: In,
     state: any
-  ): Effect.Effect<Env, never, readonly [any, Out, ScheduleDecision.ScheduleDecision]>
+  ): Effect.Effect<readonly [any, Out, ScheduleDecision.ScheduleDecision], never, Env>
 }
 
 /**
@@ -117,10 +117,10 @@ export declare namespace Schedule {
  * @category models
  */
 export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.DriverVariance<Env, In, Out> {
-  readonly state: Effect.Effect<never, never, unknown>
-  readonly last: Effect.Effect<never, Cause.NoSuchElementException, Out>
-  readonly reset: Effect.Effect<never, never, void>
-  next(input: In): Effect.Effect<Env, Option.Option<never>, Out>
+  readonly state: Effect.Effect<unknown>
+  readonly last: Effect.Effect<Out, Cause.NoSuchElementException>
+  readonly reset: Effect.Effect<void>
+  next(input: In): Effect.Effect<Out, Option.Option<never>, Env>
 }
 
 /**
@@ -136,7 +136,7 @@ export const makeWithState: <S, Env, In, Out>(
     now: number,
     input: In,
     state: S
-  ) => Effect.Effect<Env, never, readonly [S, Out, ScheduleDecision.ScheduleDecision]>
+  ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, Env>
 ) => Schedule<Env, In, Out> = internal.makeWithState
 
 /**
@@ -160,11 +160,11 @@ export const addDelay: {
  */
 export const addDelayEffect: {
   <Out, Env2>(
-    f: (out: Out) => Effect.Effect<Env2, never, Duration.DurationInput>
+    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Env2, never, Duration.DurationInput>
+    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.addDelayEffect
 
@@ -268,11 +268,11 @@ export const check: {
  */
 export const checkEffect: {
   <In, Out, Env2>(
-    test: (input: In, output: Out) => Effect.Effect<Env2, never, boolean>
+    test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>
   ): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    test: (input: In, output: Out) => Effect.Effect<Env2, never, boolean>
+    test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.checkEffect
 
@@ -310,7 +310,7 @@ export const collectUntil: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chun
  * @category utils
  */
 export const collectUntilEffect: <Env, A>(
-  f: (a: A) => Effect.Effect<Env, never, boolean>
+  f: (a: A) => Effect.Effect<boolean, never, Env>
 ) => Schedule<Env, A, Chunk.Chunk<A>> = internal.collectUntilEffect
 
 /**
@@ -330,7 +330,7 @@ export const collectWhile: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chun
  * @since 2.0.0
  */
 export const collectWhileEffect: <Env, A>(
-  f: (a: A) => Effect.Effect<Env, never, boolean>
+  f: (a: A) => Effect.Effect<boolean, never, Env>
 ) => Schedule<Env, A, Chunk.Chunk<A>> = internal.collectWhileEffect
 
 /**
@@ -390,11 +390,11 @@ export const mapInputContext: {
  */
 export const mapInputEffect: {
   <In, Env2, In2>(
-    f: (in2: In2) => Effect.Effect<Env2, never, In>
+    f: (in2: In2) => Effect.Effect<In, never, Env2>
   ): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In2, Out>
   <Env, In, Out, Env2, In2>(
     self: Schedule<Env, In, Out>,
-    f: (in2: In2) => Effect.Effect<Env2, never, In>
+    f: (in2: In2) => Effect.Effect<In, never, Env2>
   ): Schedule<Env | Env2, In2, Out>
 } = internal.mapInputEffect
 
@@ -469,11 +469,11 @@ export const delayed: {
  */
 export const delayedEffect: {
   <Env2>(
-    f: (duration: Duration.Duration) => Effect.Effect<Env2, never, Duration.DurationInput>
+    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
   ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    f: (duration: Duration.Duration) => Effect.Effect<Env2, never, Duration.DurationInput>
+    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.delayedEffect
 
@@ -528,15 +528,15 @@ export const mapBoth: {
 export const mapBothEffect: {
   <In2, Env2, In, Out, Env3, Out2>(
     options: {
-      readonly onInput: (input: In2) => Effect.Effect<Env2, never, In>
-      readonly onOutput: (out: Out) => Effect.Effect<Env3, never, Out2>
+      readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>
+      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>
     }
   ): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env3 | Env, In2, Out2>
   <Env, In, Out, In2, Env2, Env3, Out2>(
     self: Schedule<Env, In, Out>,
     options: {
-      readonly onInput: (input: In2) => Effect.Effect<Env2, never, In>
-      readonly onOutput: (out: Out) => Effect.Effect<Env3, never, Out2>
+      readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>
+      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>
     }
   ): Schedule<Env | Env2 | Env3, In2, Out2>
 } = internal.mapBothEffect
@@ -550,7 +550,7 @@ export const mapBothEffect: {
  */
 export const driver: <Env, In, Out>(
   self: Schedule<Env, In, Out>
-) => Effect.Effect<never, never, ScheduleDriver<Env, In, Out>> = internal.driver
+) => Effect.Effect<ScheduleDriver<Env, In, Out>> = internal.driver
 
 /**
  * A schedule that can recur one time, the specified amount of time into the
@@ -617,8 +617,8 @@ export const elapsed: Schedule<never, unknown, Duration.Duration> = internal.ela
  * @category finalization
  */
 export const ensuring: {
-  <X>(finalizer: Effect.Effect<never, never, X>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out, X>(self: Schedule<Env, In, Out>, finalizer: Effect.Effect<never, never, X>): Schedule<Env, In, Out>
+  <X>(finalizer: Effect.Effect<X>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
+  <Env, In, Out, X>(self: Schedule<Env, In, Out>, finalizer: Effect.Effect<X>): Schedule<Env, In, Out>
 } = internal.ensuring
 
 /**
@@ -822,11 +822,11 @@ export const map: {
  */
 export const mapEffect: {
   <Out, Env2, Out2>(
-    f: (out: Out) => Effect.Effect<Env2, never, Out2>
+    f: (out: Out) => Effect.Effect<Out2, never, Env2>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out2>
   <Env, In, Out, Env2, Out2>(
     self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Env2, never, Out2>
+    f: (out: Out) => Effect.Effect<Out2, never, Env2>
   ): Schedule<Env | Env2, In, Out2>
 } = internal.mapEffect
 
@@ -868,11 +868,11 @@ export const modifyDelay: {
  */
 export const modifyDelayEffect: {
   <Out, Env2>(
-    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Env2, never, Duration.DurationInput>
+    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Env2, never, Duration.DurationInput>
+    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.modifyDelayEffect
 
@@ -886,11 +886,11 @@ export const modifyDelayEffect: {
  */
 export const onDecision: {
   <Out, Env2, X>(
-    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<Env2, never, X>
+    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2, X>(
     self: Schedule<Env, In, Out>,
-    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<Env2, never, X>
+    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.onDecision
 
@@ -957,7 +957,7 @@ export const recurUntil: <A>(f: Predicate<A>) => Schedule<never, A, A> = interna
  * @since 2.0.0
  * @category utils
  */
-export const recurUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<Env, never, boolean>) => Schedule<Env, A, A> =
+export const recurUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, A> =
   internal.recurUntilEffect
 
 /**
@@ -994,7 +994,7 @@ export const recurWhile: <A>(f: Predicate<A>) => Schedule<never, A, A> = interna
  * @since 2.0.0
  * @category utils
  */
-export const recurWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<Env, never, boolean>) => Schedule<Env, A, A> =
+export const recurWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, A> =
   internal.recurWhileEffect
 
 /**
@@ -1026,12 +1026,12 @@ export const reduce: {
 export const reduceEffect: {
   <Out, Env1, Z>(
     zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Env1, never, Z>
+    f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In, Z>
   <Env, In, Out, Env1, Z>(
     self: Schedule<Env, In, Out>,
     zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Env1, never, Z>
+    f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>
   ): Schedule<Env | Env1, In, Z>
 } = internal.reduceEffect
 
@@ -1087,12 +1087,12 @@ export const run: {
   <In>(
     now: number,
     input: Iterable<In>
-  ): <Env, Out>(self: Schedule<Env, In, Out>) => Effect.Effect<Env, never, Chunk.Chunk<Out>>
+  ): <Env, Out>(self: Schedule<Env, In, Out>) => Effect.Effect<Chunk.Chunk<Out>, never, Env>
   <Env, In, Out>(
     self: Schedule<Env, In, Out>,
     now: number,
     input: Iterable<In>
-  ): Effect.Effect<Env, never, Chunk.Chunk<Out>>
+  ): Effect.Effect<Chunk.Chunk<Out>, never, Env>
 } = internal.run
 
 /**
@@ -1151,11 +1151,11 @@ export const sync: <A>(evaluate: LazyArg<A>) => Schedule<never, unknown, A> = in
  */
 export const tapInput: {
   <Env2, In2, X>(
-    f: (input: In2) => Effect.Effect<Env2, never, X>
+    f: (input: In2) => Effect.Effect<X, never, Env2>
   ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out>
   <Env, In, Out, Env2, In2, X>(
     self: Schedule<Env, In, Out>,
-    f: (input: In2) => Effect.Effect<Env2, never, X>
+    f: (input: In2) => Effect.Effect<X, never, Env2>
   ): Schedule<Env | Env2, In & In2, Out>
 } = internal.tapInput
 
@@ -1168,11 +1168,11 @@ export const tapInput: {
  */
 export const tapOutput: {
   <Out, XO extends Out, Env2, X>(
-    f: (out: XO) => Effect.Effect<Env2, never, X>
+    f: (out: XO) => Effect.Effect<X, never, Env2>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, XO extends Out, Env2, X>(
     self: Schedule<Env, In, Out>,
-    f: (out: XO) => Effect.Effect<Env2, never, X>
+    f: (out: XO) => Effect.Effect<X, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.tapOutput
 
@@ -1243,11 +1243,11 @@ export const untilInput: {
  */
 export const untilInputEffect: {
   <In, Env2>(
-    f: (input: In) => Effect.Effect<Env2, never, boolean>
+    f: (input: In) => Effect.Effect<boolean, never, Env2>
   ): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    f: (input: In) => Effect.Effect<Env2, never, boolean>
+    f: (input: In) => Effect.Effect<boolean, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.untilInputEffect
 
@@ -1272,11 +1272,11 @@ export const untilOutput: {
  */
 export const untilOutputEffect: {
   <Out, Env2>(
-    f: (out: Out) => Effect.Effect<Env2, never, boolean>
+    f: (out: Out) => Effect.Effect<boolean, never, Env2>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Env2, never, boolean>
+    f: (out: Out) => Effect.Effect<boolean, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.untilOutputEffect
 
@@ -1312,11 +1312,11 @@ export const whileInput: {
  */
 export const whileInputEffect: {
   <In, Env2>(
-    f: (input: In) => Effect.Effect<Env2, never, boolean>
+    f: (input: In) => Effect.Effect<boolean, never, Env2>
   ): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
   <Env, In, Out, Env2>(
     self: Schedule<Env, In, Out>,
-    f: (input: In) => Effect.Effect<Env2, never, boolean>
+    f: (input: In) => Effect.Effect<boolean, never, Env2>
   ): Schedule<Env | Env2, In, Out>
 } = internal.whileInputEffect
 
@@ -1341,11 +1341,11 @@ export const whileOutput: {
  */
 export const whileOutputEffect: {
   <Out, Env1>(
-    f: (out: Out) => Effect.Effect<Env1, never, boolean>
+    f: (out: Out) => Effect.Effect<boolean, never, Env1>
   ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In, Out>
   <Env, In, Out, Env1>(
     self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Env1, never, boolean>
+    f: (out: Out) => Effect.Effect<boolean, never, Env1>
   ): Schedule<Env | Env1, In, Out>
 } = internal.whileOutputEffect
 

package/src/Scheduler.ts

@@ -354,6 +354,6 @@ export const currentScheduler: FiberRef<Scheduler> = globalValue(
 
 /** @internal */
 export const withScheduler = dual<
-  (scheduler: Scheduler) => <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>,
-  <R, E, B>(self: Effect<R, E, B>, scheduler: Scheduler) => Effect<R, E, B>
+  (scheduler: Scheduler) => <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>,
+  <A, E, R>(self: Effect<A, E, R>, scheduler: Scheduler) => Effect<A, E, R>
 >(2, (self, scheduler) => core.fiberRefLocally(self, currentScheduler, scheduler))

package/src/Scope.ts

@@ -44,11 +44,11 @@ export interface Scope extends Pipeable {
   /**
    * @internal
    */
-  fork(strategy: ExecutionStrategy.ExecutionStrategy): Effect.Effect<never, never, Scope.Closeable>
+  fork(strategy: ExecutionStrategy.ExecutionStrategy): Effect.Effect<Scope.Closeable>
   /**
    * @internal
    */
-  addFinalizer(finalizer: Scope.Finalizer): Effect.Effect<never, never, void>
+  addFinalizer(finalizer: Scope.Finalizer): Effect.Effect<void>
 }
 
 /**
@@ -61,7 +61,7 @@ export interface CloseableScope extends Scope, Pipeable {
   /**
    * @internal
    */
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never, never, void>
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<void>
 }
 
 /**
@@ -78,7 +78,7 @@ export declare namespace Scope {
    * @since 2.0.0
    * @category model
    */
-  export type Finalizer = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
+  export type Finalizer = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>
   /**
    * @since 2.0.0
    * @category model
@@ -95,8 +95,8 @@ export declare namespace Scope {
  */
 export const addFinalizer: (
   self: Scope,
-  finalizer: Effect.Effect<never, never, unknown>
-) => Effect.Effect<never, never, void> = core.scopeAddFinalizer
+  finalizer: Effect.Effect<unknown>
+) => Effect.Effect<void> = core.scopeAddFinalizer
 
 /**
  * A simplified version of `addFinalizerWith` when the `finalizer` does not
@@ -105,7 +105,7 @@ export const addFinalizer: (
  * @since 2.0.0
  * @category utils
  */
-export const addFinalizerExit: (self: Scope, finalizer: Scope.Finalizer) => Effect.Effect<never, never, void> =
+export const addFinalizerExit: (self: Scope, finalizer: Scope.Finalizer) => Effect.Effect<void> =
   core.scopeAddFinalizerExit
 
 /**
@@ -115,8 +115,7 @@ export const addFinalizerExit: (self: Scope, finalizer: Scope.Finalizer) => Effe
  * @since 2.0.0
  * @category destructors
  */
-export const close: (self: CloseableScope, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void> =
-  core.scopeClose
+export const close: (self: CloseableScope, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void> = core.scopeClose
 
 /**
  * Extends the scope of an `Effect` workflow that needs a scope into this
@@ -128,8 +127,8 @@ export const close: (self: CloseableScope, exit: Exit.Exit<unknown, unknown>) =>
  * @category utils
  */
 export const extend: {
-  (scope: Scope): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<Exclude<R, Scope>, E, A>
-  <R, E, A>(effect: Effect.Effect<R, E, A>, scope: Scope): Effect.Effect<Exclude<R, Scope>, E, A>
+  (scope: Scope): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Scope>>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, scope: Scope): Effect.Effect<A, E, Exclude<R, Scope>>
 } = fiberRuntime.scopeExtend
 
 /**
@@ -142,7 +141,7 @@ export const extend: {
 export const fork: (
   self: Scope,
   strategy: ExecutionStrategy.ExecutionStrategy
-) => Effect.Effect<never, never, CloseableScope> = core.scopeFork
+) => Effect.Effect<CloseableScope> = core.scopeFork
 
 /**
  * Uses the scope by providing it to an `Effect` workflow that needs a scope,
@@ -154,8 +153,8 @@ export const fork: (
  * @category destructors
  */
 export const use: {
-  (scope: CloseableScope): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<Exclude<R, Scope>, E, A>
-  <R, E, A>(effect: Effect.Effect<R, E, A>, scope: CloseableScope): Effect.Effect<Exclude<R, Scope>, E, A>
+  (scope: CloseableScope): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Scope>>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, scope: CloseableScope): Effect.Effect<A, E, Exclude<R, Scope>>
 } = fiberRuntime.scopeUse
 
 /**
@@ -168,4 +167,4 @@ export const use: {
  */
 export const make: (
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-) => Effect.Effect<never, never, CloseableScope> = fiberRuntime.scopeMake
+) => Effect.Effect<CloseableScope> = fiberRuntime.scopeMake

package/src/ScopedCache.ts

@@ -32,47 +32,47 @@ export interface ScopedCache<in Key, out Error, out Value> extends ScopedCache.V
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
    */
-  getOption(key: Key): Effect.Effect<Scope.Scope, Error, Option.Option<Value>>
+  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error, Scope.Scope>
 
   /**
    * Retrieves the value associated with the specified key if it exists and the
    * lookup function has completed. Otherwise returns `Option.none`.
    */
-  getOptionComplete(key: Key): Effect.Effect<Scope.Scope, never, Option.Option<Value>>
+  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>, never, Scope.Scope>
 
   /**
    * Returns statistics for this cache.
    */
-  readonly cacheStats: Effect.Effect<never, never, Cache.CacheStats>
+  readonly cacheStats: Effect.Effect<Cache.CacheStats>
 
   /**
    * Return whether a resource associated with the specified key exists in the
    * cache. Sometime `contains` can return true if the resource is currently
    * being created but not yet totally created.
    */
-  contains(key: Key): Effect.Effect<never, never, boolean>
+  contains(key: Key): Effect.Effect<boolean>
 
   /**
    * Return statistics for the specified entry.
    */
-  entryStats(key: Key): Effect.Effect<never, never, Option.Option<Cache.EntryStats>>
+  entryStats(key: Key): Effect.Effect<Option.Option<Cache.EntryStats>>
 
   /**
    * Gets the value from the cache if it exists or otherwise computes it, the
    * release action signals to the cache that the value is no longer being used
    * and can potentially be finalized subject to the policies of the cache.
    */
-  get(key: Key): Effect.Effect<Scope.Scope, Error, Value>
+  get(key: Key): Effect.Effect<Value, Error, Scope.Scope>
 
   /**
    * Invalidates the resource associated with the specified key.
    */
-  invalidate(key: Key): Effect.Effect<never, never, void>
+  invalidate(key: Key): Effect.Effect<void>
 
   /**
    * Invalidates all values in the cache.
    */
-  readonly invalidateAll: Effect.Effect<never, never, void>
+  readonly invalidateAll: Effect.Effect<void>
 
   /**
    * Force the reuse of the lookup function to compute the returned scoped
@@ -82,12 +82,12 @@ export interface ScopedCache<in Key, out Error, out Value> extends ScopedCache.V
    * computed, concurrent call the .get will use the old resource if this one is
    * not expired.
    */
-  refresh(key: Key): Effect.Effect<never, Error, void>
+  refresh(key: Key): Effect.Effect<void, Error>
 
   /**
    * Returns the approximate number of values in the cache.
    */
-  readonly size: Effect.Effect<never, never, number>
+  readonly size: Effect.Effect<number>
 }
 
 /**
@@ -120,7 +120,7 @@ export const make: <Key, Environment, Error, Value>(
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
   }
-) => Effect.Effect<Scope.Scope | Environment, never, ScopedCache<Key, Error, Value>> = internal.make
+) => Effect.Effect<ScopedCache<Key, Error, Value>, never, Scope.Scope | Environment> = internal.make
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -134,9 +134,9 @@ export const makeWith: <Key, Environment, Error, Value>(
   options: {
     readonly capacity: number
     readonly lookup: Lookup<Key, Environment, Error, Value>
-    readonly timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.DurationInput
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-) => Effect.Effect<Scope.Scope | Environment, never, ScopedCache<Key, Error, Value>> = internal.makeWith
+) => Effect.Effect<ScopedCache<Key, Error, Value>, never, Scope.Scope | Environment> = internal.makeWith
 
 /**
  * Similar to `Cache.Lookup`, but executes the lookup function within a `Scope`.
@@ -146,4 +146,4 @@ export const makeWith: <Key, Environment, Error, Value>(
  */
 export type Lookup<Key, Environment, Error, Value> = (
   key: Key
-) => Effect.Effect<Environment | Scope.Scope, Error, Value>
+) => Effect.Effect<Value, Error, Environment | Scope.Scope>

package/src/ScopedRef.ts

@@ -58,9 +58,9 @@ export declare namespace ScopedRef {
  * @since 2.0.0
  * @category constructors
  */
-export const fromAcquire: <R, E, A>(
-  acquire: Effect.Effect<R, E, A>
-) => Effect.Effect<Scope.Scope | R, E, ScopedRef<A>> = internal.fromAcquire
+export const fromAcquire: <A, E, R>(
+  acquire: Effect.Effect<A, E, R>
+) => Effect.Effect<ScopedRef<A>, E, Scope.Scope | R> = internal.fromAcquire
 
 /**
  * Retrieves the current value of the scoped reference.
@@ -68,7 +68,7 @@ export const fromAcquire: <R, E, A>(
  * @since 2.0.0
  * @category getters
  */
-export const get: <A>(self: ScopedRef<A>) => Effect.Effect<never, never, A> = internal.get
+export const get: <A>(self: ScopedRef<A>) => Effect.Effect<A> = internal.get
 
 /**
  * Creates a new `ScopedRef` from the specified value. This method should
@@ -77,7 +77,7 @@ export const get: <A>(self: ScopedRef<A>) => Effect.Effect<never, never, A> = in
  * @since 2.0.0
  * @category constructors
  */
-export const make: <A>(evaluate: LazyArg<A>) => Effect.Effect<Scope.Scope, never, ScopedRef<A>> = internal.make
+export const make: <A>(evaluate: LazyArg<A>) => Effect.Effect<ScopedRef<A>, never, Scope.Scope> = internal.make
 
 /**
  * Sets the value of this reference to the specified resourcefully-created
@@ -91,6 +91,6 @@ export const make: <A>(evaluate: LazyArg<A>) => Effect.Effect<Scope.Scope, never
  * @category getters
  */
 export const set: {
-  <A, R, E>(acquire: Effect.Effect<R, E, A>): (self: ScopedRef<A>) => Effect.Effect<Exclude<R, Scope.Scope>, E, void>
-  <A, R, E>(self: ScopedRef<A>, acquire: Effect.Effect<R, E, A>): Effect.Effect<Exclude<R, Scope.Scope>, E, void>
+  <A, R, E>(acquire: Effect.Effect<A, E, R>): (self: ScopedRef<A>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>
+  <A, R, E>(self: ScopedRef<A>, acquire: Effect.Effect<A, E, R>): Effect.Effect<void, E, Exclude<R, Scope.Scope>>
 } = internal.set

package/src/SingleProducerAsyncInput.ts

@@ -29,8 +29,8 @@ import * as internal from "./internal/channel/singleProducerAsyncInput.js"
 export interface SingleProducerAsyncInput<in out Err, in out Elem, in out Done>
   extends AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done>
 {
-  readonly close: Effect.Effect<never, never, unknown>
-  readonly take: Effect.Effect<never, never, Exit.Exit<Either.Either<Err, Done>, Elem>>
+  readonly close: Effect.Effect<unknown>
+  readonly take: Effect.Effect<Exit.Exit<Elem, Either.Either<Err, Done>>>
 }
 
 /**
@@ -40,10 +40,10 @@ export interface SingleProducerAsyncInput<in out Err, in out Elem, in out Done>
  * @category models
  */
 export interface AsyncInputProducer<in Err, in Elem, in Done> {
-  awaitRead(): Effect.Effect<never, never, unknown>
-  done(value: Done): Effect.Effect<never, never, unknown>
-  emit(element: Elem): Effect.Effect<never, never, unknown>
-  error(cause: Cause.Cause<Err>): Effect.Effect<never, never, unknown>
+  awaitRead(): Effect.Effect<unknown>
+  done(value: Done): Effect.Effect<unknown>
+  emit(element: Elem): Effect.Effect<unknown>
+  error(cause: Cause.Cause<Err>): Effect.Effect<unknown>
 }
 
 /**
@@ -57,12 +57,11 @@ export interface AsyncInputConsumer<out Err, out Elem, out Done> {
     onError: (cause: Cause.Cause<Err>) => A,
     onElement: (element: Elem) => A,
     onDone: (value: Done) => A
-  ): Effect.Effect<never, never, A>
+  ): Effect.Effect<A>
 }
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const make: <Err, Elem, Done>() => Effect.Effect<never, never, SingleProducerAsyncInput<Err, Elem, Done>> =
-  internal.make
+export const make: <Err, Elem, Done>() => Effect.Effect<SingleProducerAsyncInput<Err, Elem, Done>> = internal.make