effect 2.2.5 → 2.3.1

package/src/LogLevel.ts

@@ -178,12 +178,13 @@ export const allLevels = core.allLogLevels
  * @category utils
  */
 export const locally: {
-  (self: LogLevel): <R, E, B>(use: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B>
-  <R, E, B>(use: Effect.Effect<R, E, B>, self: LogLevel): Effect.Effect<R, E, B>
-} = dual<
-  (self: LogLevel) => <R, E, B>(use: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B>,
-  <R, E, B>(use: Effect.Effect<R, E, B>, self: LogLevel) => Effect.Effect<R, E, B>
->(2, (use, self) => core.fiberRefLocally(use, core.currentLogLevel, self))
+  (self: LogLevel): <A, E, R>(use: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(use: Effect.Effect<A, E, R>, self: LogLevel): Effect.Effect<A, E, R>
+} = dual(
+  2,
+  <A, E, R>(use: Effect.Effect<A, E, R>, self: LogLevel): Effect.Effect<A, E, R> =>
+    core.fiberRefLocally(use, core.currentLogLevel, self)
+)
 
 /**
  * @since 2.0.0

package/src/Logger.ts

@@ -82,22 +82,22 @@ export const make: <Message, Output>(log: (options: Logger.Options<Message>) =>
  * @since 2.0.0
  * @category context
  */
-export const add: <B>(logger: Logger<unknown, B>) => Layer.Layer<never, never, never> = circular.addLogger
+export const add: <B>(logger: Logger<unknown, B>) => Layer.Layer<never> = circular.addLogger
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const addEffect: <R, E, A>(effect: Effect<R, E, Logger<unknown, A>>) => Layer.Layer<R, E, never> =
+export const addEffect: <A, E, R>(effect: Effect<Logger<unknown, A>, E, R>) => Layer.Layer<never, E, R> =
   circular.addLoggerEffect
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const addScoped: <R, E, A>(
-  effect: Effect<R, E, Logger<unknown, A>>
-) => Layer.Layer<Exclude<R, Scope>, E, never> = circular.addLoggerScoped
+export const addScoped: <A, E, R>(
+  effect: Effect<Logger<unknown, A>, E, R>
+) => Layer.Layer<never, E, Exclude<R, Scope>> = circular.addLoggerScoped
 
 /**
  * @since 2.0.0
@@ -170,15 +170,15 @@ export const none: Logger<unknown, void> = internal.none
  * @since 2.0.0
  * @category context
  */
-export const remove: <A>(logger: Logger<unknown, A>) => Layer.Layer<never, never, never> = circular.removeLogger
+export const remove: <A>(logger: Logger<unknown, A>) => Layer.Layer<never> = circular.removeLogger
 
 /**
  * @since 2.0.0
  * @category context
  */
 export const replace: {
-  <B>(that: Logger<unknown, B>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, never, never>
-  <A, B>(self: Logger<unknown, A>, that: Logger<unknown, B>): Layer.Layer<never, never, never>
+  <B>(that: Logger<unknown, B>): <A>(self: Logger<unknown, A>) => Layer.Layer<never>
+  <A, B>(self: Logger<unknown, A>, that: Logger<unknown, B>): Layer.Layer<never>
 } = circular.replaceLogger
 
 /**
@@ -186,8 +186,8 @@ export const replace: {
  * @category context
  */
 export const replaceEffect: {
-  <R, E, B>(that: Effect<R, E, Logger<unknown, B>>): <A>(self: Logger<unknown, A>) => Layer.Layer<R, E, never>
-  <A, R, E, B>(self: Logger<unknown, A>, that: Effect<R, E, Logger<unknown, B>>): Layer.Layer<R, E, never>
+  <R, E, B>(that: Effect<Logger<unknown, B>, E, R>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, R>
+  <A, R, E, B>(self: Logger<unknown, A>, that: Effect<Logger<unknown, B>, E, R>): Layer.Layer<never, E, R>
 } = circular.replaceLoggerEffect
 
 /**
@@ -196,12 +196,12 @@ export const replaceEffect: {
  */
 export const replaceScoped: {
   <R, E, B>(
-    that: Effect<R, E, Logger<unknown, B>>
-  ): <A>(self: Logger<unknown, A>) => Layer.Layer<Exclude<R, Scope>, E, never>
+    that: Effect<Logger<unknown, B>, E, R>
+  ): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>
   <A, R, E, B>(
     self: Logger<unknown, A>,
-    that: Effect<R, E, Logger<unknown, B>>
-  ): Layer.Layer<Exclude<R, Scope>, E, never>
+    that: Effect<Logger<unknown, B>, E, R>
+  ): Layer.Layer<never, E, Exclude<R, Scope>>
 } = circular.replaceLoggerScoped
 
 /**
@@ -236,8 +236,8 @@ export const test: {
  * @category context
  */
 export const withMinimumLogLevel: {
-  (level: LogLevel.LogLevel): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(self: Effect<R, E, A>, level: LogLevel.LogLevel): Effect<R, E, A>
+  (level: LogLevel.LogLevel): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
+  <A, E, R>(self: Effect<A, E, R>, level: LogLevel.LogLevel): Effect<A, E, R>
 } = circular.withMinimumLogLevel
 
 /**
@@ -320,10 +320,10 @@ export const tracerLogger: Logger<unknown, void> = fiberRuntime.tracerLogger
  * @since 2.0.0
  * @category constructors
  */
-export const logFmt: Layer.Layer<never, never, never> = replace(fiberRuntime.defaultLogger, fiberRuntime.logFmtLogger)
+export const logFmt: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.logFmtLogger)
 
 /**
  * @since 2.0.0
  * @category context
  */
-export const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer<never, never, never> = circular.minimumLogLevel
+export const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer<never> = circular.minimumLogLevel

package/src/MergeDecision.ts

@@ -47,21 +47,21 @@ export declare namespace MergeDecision {
  * @since 2.0.0
  * @category constructors
  */
-export const Done: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => MergeDecision<R, unknown, unknown, E, Z> = internal.Done
+export const Done: <Z, E, R>(effect: Effect.Effect<Z, E, R>) => MergeDecision<R, unknown, unknown, E, Z> = internal.Done
 
 /**
  * @since 2.0.0
  * @category constructors
  */
 export const Await: <R, E0, Z0, E, Z>(
-  f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>
+  f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>
 ) => MergeDecision<R, E0, Z0, E, Z> = internal.Await
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const AwaitConst: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => MergeDecision<R, unknown, unknown, E, Z> =
+export const AwaitConst: <R, E, Z>(effect: Effect.Effect<Z, E, R>) => MergeDecision<R, unknown, unknown, E, Z> =
   internal.AwaitConst
 
 /**
@@ -81,15 +81,15 @@ export const isMergeDecision: (u: unknown) => u is MergeDecision<unknown, unknow
 export const match: {
   <R, E0, Z0, E, Z, Z2>(
     options: {
-      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
     }
   ): (self: MergeDecision<R, E0, Z0, E, Z>) => Z2
   <R, E0, Z0, E, Z, Z2>(
     self: MergeDecision<R, E0, Z0, E, Z>,
     options: {
-      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
     }
   ): Z2
 } = internal.match

package/src/MergeState.ts

@@ -49,8 +49,8 @@ export interface BothRunning<_Env, out Err, out Err1, _Err2, out Elem, out Done,
   extends MergeState.Proto
 {
   readonly _tag: "BothRunning"
-  readonly left: Fiber.Fiber<Err, Either.Either<Done, Elem>>
-  readonly right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+  readonly left: Fiber.Fiber<Either.Either<Done, Elem>, Err>
+  readonly right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
 }
 
 /**
@@ -61,7 +61,7 @@ export interface LeftDone<out Env, _Err, in Err1, out Err2, _Elem, _Done, in Don
   extends MergeState.Proto
 {
   readonly _tag: "LeftDone"
-  f(exit: Exit.Exit<Err1, Done1>): Effect.Effect<Env, Err2, Done2>
+  f(exit: Exit.Exit<Done1, Err1>): Effect.Effect<Done2, Err2, Env>
 }
 
 /**
@@ -72,7 +72,7 @@ export interface RightDone<out Env, in Err, _Err1, out Err2, _Elem, in Done, _Do
   extends MergeState.Proto
 {
   readonly _tag: "RightDone"
-  f(exit: Exit.Exit<Err, Done>): Effect.Effect<Env, Err2, Done2>
+  f(exit: Exit.Exit<Done, Err>): Effect.Effect<Done2, Err2, Env>
 }
 
 /**
@@ -80,8 +80,8 @@ export interface RightDone<out Env, in Err, _Err1, out Err2, _Elem, in Done, _Do
  * @category constructors
  */
 export const BothRunning: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-  right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+  left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+  right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
 ) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.BothRunning
 
 /**
@@ -89,7 +89,7 @@ export const BothRunning: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
  * @category constructors
  */
 export const LeftDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>
+  f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>
 ) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.LeftDone
 
 /**
@@ -97,7 +97,7 @@ export const LeftDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
  * @category constructors
  */
 export const RightDone: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>
+  f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>
 ) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.RightDone
 
 /**
@@ -151,22 +151,22 @@ export const match: {
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
-      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
-      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
     }
   ): (self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>) => Z
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
-      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
-      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
     }
   ): Z
 } = internal.match

package/src/Metric.ts

@@ -57,7 +57,7 @@ export interface Metric<in out Type, in In, out Out> extends Metric.Variance<Typ
   unsafeUpdate(input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>): void
   unsafeValue(extraTags: ReadonlyArray<MetricLabel.MetricLabel>): Out
   register(): this
-  <R, E, A extends In>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
+  <R, E, A extends In>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
 }
 
 /**
@@ -302,7 +302,7 @@ export const histogram: (
  * @since 2.0.0
  * @category aspects
  */
-export const increment: (self: Metric.Counter<number> | Metric.Counter<bigint>) => Effect.Effect<never, never, void> =
+export const increment: (self: Metric.Counter<number> | Metric.Counter<bigint>) => Effect.Effect<void> =
   internal.increment
 
 /**
@@ -310,10 +310,10 @@ export const increment: (self: Metric.Counter<number> | Metric.Counter<bigint>)
  * @category aspects
  */
 export const incrementBy: {
-  (amount: number): (self: Metric.Counter<number>) => Effect.Effect<never, never, void>
-  (amount: bigint): (self: Metric.Counter<bigint>) => Effect.Effect<never, never, void>
-  (self: Metric.Counter<number>, amount: number): Effect.Effect<never, never, void>
-  (self: Metric.Counter<bigint>, amount: bigint): Effect.Effect<never, never, void>
+  (amount: number): (self: Metric.Counter<number>) => Effect.Effect<void>
+  (amount: bigint): (self: Metric.Counter<bigint>) => Effect.Effect<void>
+  (self: Metric.Counter<number>, amount: number): Effect.Effect<void>
+  (self: Metric.Counter<bigint>, amount: bigint): Effect.Effect<void>
 } = internal.incrementBy
 
 /**
@@ -343,10 +343,10 @@ export const mapType: {
  * @category aspects
  */
 export const set: {
-  (value: number): (self: Metric.Gauge<number>) => Effect.Effect<never, never, void>
-  (value: bigint): (self: Metric.Gauge<bigint>) => Effect.Effect<never, never, void>
-  (self: Metric.Gauge<number>, value: number): Effect.Effect<never, never, void>
-  (self: Metric.Gauge<bigint>, value: bigint): Effect.Effect<never, never, void>
+  (value: number): (self: Metric.Gauge<number>) => Effect.Effect<void>
+  (value: bigint): (self: Metric.Gauge<bigint>) => Effect.Effect<void>
+  (self: Metric.Gauge<number>, value: number): Effect.Effect<void>
+  (self: Metric.Gauge<bigint>, value: bigint): Effect.Effect<void>
 } = internal.set
 
 /**
@@ -355,7 +355,7 @@ export const set: {
  * @since 2.0.0
  * @category getters
  */
-export const snapshot: Effect.Effect<never, never, ReadonlyArray<MetricPair.MetricPair.Untyped>> = internal.snapshot
+export const snapshot: Effect.Effect<ReadonlyArray<MetricPair.MetricPair.Untyped>> = internal.snapshot
 
 /**
  * Creates a metric that ignores input and produces constant output.
@@ -512,11 +512,11 @@ export const timerWithBoundaries: (
 export const trackAll: {
   <In>(
     input: In
-  ): <Type, Out>(self: Metric<Type, In, Out>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <Type, Out>(self: Metric<Type, In, Out>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <Type, In, Out>(
     self: Metric<Type, In, Out>,
     input: In
-  ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 } = internal.trackAll
 
 /**
@@ -527,8 +527,8 @@ export const trackAll: {
  * @category aspects
  */
 export const trackDefect: {
-  <Type, Out>(metric: Metric<Type, unknown, Out>): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
-  <R, E, A, Type, Out>(self: Effect.Effect<R, E, A>, metric: Metric<Type, unknown, Out>): Effect.Effect<R, E, A>
+  <Type, Out>(metric: Metric<Type, unknown, Out>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <R, E, A, Type, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, unknown, Out>): Effect.Effect<A, E, R>
 } = internal.trackDefect
 
 /**
@@ -543,12 +543,12 @@ export const trackDefectWith: {
   <Type, In, Out>(
     metric: Metric<Type, In, Out>,
     f: (defect: unknown) => In
-  ): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E, A, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (defect: unknown) => In
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackDefectWith
 
 /**
@@ -562,11 +562,11 @@ export const trackDefectWith: {
 export const trackDuration: {
   <Type, Out>(
     metric: Metric<Type, Duration.Duration, Out>
-  ): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E, A, Type, Out>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, Duration.Duration, Out>
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackDuration
 
 /**
@@ -581,12 +581,12 @@ export const trackDurationWith: {
   <Type, In, Out>(
     metric: Metric<Type, In, Out>,
     f: (duration: Duration.Duration) => In
-  ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E, A, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (duration: Duration.Duration) => In
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackDurationWith
 
 /**
@@ -599,11 +599,11 @@ export const trackDurationWith: {
 export const trackError: {
   <Type, In, Out>(
     metric: Metric<Type, In, Out>
-  ): <R, E extends In, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <R, E extends In, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E extends In, A, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackError
 
 /**
@@ -618,12 +618,12 @@ export const trackErrorWith: {
   <Type, In, Out, In2>(
     metric: Metric<Type, In, Out>,
     f: (error: In2) => In
-  ): <R, E extends In2, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <R, E extends In2, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E extends In2, A, Type, In, Out, In2>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (error: In2) => In
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackErrorWith
 
 /**
@@ -636,11 +636,11 @@ export const trackErrorWith: {
 export const trackSuccess: {
   <Type, In, Out>(
     metric: Metric<Type, In, Out>
-  ): <R, E, A extends In>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <R, E, A extends In>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E, A extends In, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackSuccess
 
 /**
@@ -655,12 +655,12 @@ export const trackSuccessWith: {
   <Type, In, Out, In2>(
     metric: Metric<Type, In, Out>,
     f: (value: In2) => In
-  ): <R, E, A extends In2>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ): <R, E, A extends In2>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <R, E, A extends In2, Type, In, Out, In2>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (value: In2) => In
-  ): Effect.Effect<R, E, A>
+  ): Effect.Effect<A, E, R>
 } = internal.trackSuccessWith
 
 /**
@@ -672,8 +672,8 @@ export const trackSuccessWith: {
  * @category utils
  */
 export const update: {
-  <In>(input: In): <Type, Out>(self: Metric<Type, In, Out>) => Effect.Effect<never, never, void>
-  <Type, In, Out>(self: Metric<Type, In, Out>, input: In): Effect.Effect<never, never, void>
+  <In>(input: In): <Type, Out>(self: Metric<Type, In, Out>) => Effect.Effect<void>
+  <Type, In, Out>(self: Metric<Type, In, Out>, input: In): Effect.Effect<void>
 } = internal.update
 
 /**
@@ -682,7 +682,7 @@ export const update: {
  * @since 2.0.0
  * @category getters
  */
-export const value: <Type, In, Out>(self: Metric<Type, In, Out>) => Effect.Effect<never, never, Out> = internal.value
+export const value: <Type, In, Out>(self: Metric<Type, In, Out>) => Effect.Effect<Out> = internal.value
 
 /**
  * @since 2.0.0

package/src/MetricPolling.ts

@@ -37,7 +37,7 @@ export interface MetricPolling<in out Type, in out In, out R, out E, out Out> ex
   /**
    * An effect that polls a value that may be fed to the metric.
    */
-  readonly poll: Effect.Effect<R, E, In>
+  readonly poll: Effect.Effect<In, E, R>
 }
 
 /**
@@ -48,7 +48,7 @@ export interface MetricPolling<in out Type, in out In, out R, out E, out Out> ex
  */
 export const make: <Type, In, Out, R, E>(
   metric: Metric.Metric<Type, In, Out>,
-  poll: Effect.Effect<R, E, In>
+  poll: Effect.Effect<In, E, R>
 ) => MetricPolling<Type, In, R, E, Out> = internal.make
 
 /**
@@ -74,11 +74,11 @@ export const launch: {
     schedule: Schedule.Schedule<R2, unknown, A2>
   ): <Type, In, R, E, Out>(
     self: MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<R2 | R | Scope.Scope, never, Fiber.Fiber<E, A2>>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R2 | R>
   <Type, In, R, E, Out, R2, A2>(
     self: MetricPolling<Type, In, R, E, Out>,
     schedule: Schedule.Schedule<R2, unknown, A2>
-  ): Effect.Effect<Scope.Scope | R | R2, never, Fiber.Fiber<E, A2>>
+  ): Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R | R2>
 } = internal.launch
 
 /**
@@ -87,7 +87,7 @@ export const launch: {
  * @since 2.0.0
  * @category utils
  */
-export const poll: <Type, In, R, E, Out>(self: MetricPolling<Type, In, R, E, Out>) => Effect.Effect<R, E, In> =
+export const poll: <Type, In, R, E, Out>(self: MetricPolling<Type, In, R, E, Out>) => Effect.Effect<In, E, R> =
   internal.poll
 
 /**
@@ -98,7 +98,7 @@ export const poll: <Type, In, R, E, Out>(self: MetricPolling<Type, In, R, E, Out
  */
 export const pollAndUpdate: <Type, In, R, E, Out>(
   self: MetricPolling<Type, In, R, E, Out>
-) => Effect.Effect<R, E, void> = internal.pollAndUpdate
+) => Effect.Effect<void, E, R> = internal.pollAndUpdate
 
 /**
  * Returns a new polling metric whose poll function will be retried with the

package/src/Number.ts

@@ -448,3 +448,22 @@ export const remainder: {
   const divisorInt = parseInt(divisor.toFixed(decCount).replace(".", ""))
   return (selfInt % divisorInt) / Math.pow(10, decCount)
 })
+
+/**
+ * Returns the next power of 2 from the given number.
+ *
+ * @param self - The number to find the next power of 2 from.
+ *
+ * @example
+ * import { nextPow2 } from "effect/Number"
+ *
+ * assert.deepStrictEqual(nextPow2(5), 8)
+ * assert.deepStrictEqual(nextPow2(17), 32)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const nextPow2 = (n: number): number => {
+  const nextPow = Math.ceil(Math.log(n) / Math.log(2))
+  return Math.max(Math.pow(2, nextPow), 2)
+}

package/src/Option.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-import type * as Data from "./Data.js"
 import type { Either } from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
@@ -41,7 +40,7 @@ export type TypeId = typeof TypeId
  * @category models
  * @since 2.0.0
  */
-export interface None<out A> extends Data.Case, Pipeable, Inspectable {
+export interface None<out A> extends Pipeable, Inspectable {
   readonly _tag: "None"
   readonly _op: "None"
   readonly [TypeId]: {
@@ -56,7 +55,7 @@ export interface None<out A> extends Data.Case, Pipeable, Inspectable {
  * @category models
  * @since 2.0.0
  */
-export interface Some<out A> extends Data.Case, Pipeable, Inspectable {
+export interface Some<out A> extends Pipeable, Inspectable {
   readonly _tag: "Some"
   readonly _op: "Some"
   readonly value: A