effect 2.3.8 → 2.4.0

package/src/Equal.ts

@@ -62,4 +62,4 @@ export const isEqual = (u: unknown): u is Equal => hasProperty(u, symbol)
  * @since 2.0.0
  * @category instances
  */
-export const equivalence: <A>() => Equivalence<A> = () => (self, that) => equals(self, that)
+export const equivalence: <A>() => Equivalence<A> = () => equals

package/src/Exit.ts

@@ -226,12 +226,12 @@ export const forEachEffect: {
 } = core.exitForEachEffect
 
 /**
- * Converts an `Either<E, A>` into an `Exit<A, E>`.
+ * Converts an `Either<R, L>` into an `Exit<R, L>`.
  *
  * @since 2.0.0
  * @category conversions
  */
-export const fromEither: <E, A>(either: Either.Either<E, A>) => Exit<A, E> = core.exitFromEither
+export const fromEither: <R, L>(either: Either.Either<R, L>) => Exit<R, L> = core.exitFromEither
 
 /**
  * Converts an `Option<A>` into an `Exit<void, A>`.

package/src/Fiber.ts

@@ -539,8 +539,8 @@ export const orElse: {
  * @category alternatives
  */
 export const orElseEither: {
-  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<Either.Either<A, A2>, E2 | E>
-  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<Either.Either<A, A2>, E | E2>
+  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<Either.Either<A2, A>, E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<Either.Either<A2, A>, E | E2>
 } = internal.orElseEither
 
 /**

package/src/GroupBy.ts

@@ -29,7 +29,7 @@ export type GroupByTypeId = typeof GroupByTypeId
  * @since 2.0.0
  * @category models
  */
-export interface GroupBy<out R, out E, out K, out V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
+export interface GroupBy<out K, out V, out E = never, out R = never> extends GroupBy.Variance<K, V, E, R>, Pipeable {
   readonly grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
 }
 
@@ -41,12 +41,12 @@ export declare namespace GroupBy {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out R, out E, out K, out V> {
+  export interface Variance<out K, out V, out E, out R> {
     readonly [GroupByTypeId]: {
-      readonly _R: Covariant<R>
-      readonly _E: Covariant<E>
       readonly _K: Covariant<K>
       readonly _V: Covariant<V>
+      readonly _E: Covariant<E>
+      readonly _R: Covariant<R>
     }
   }
 }
@@ -59,13 +59,13 @@ export declare namespace GroupBy {
  * @category destructors
  */
 export const evaluate: {
-  <K, E, V, R2, E2, A>(
-    f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
+  <K, V, E, A, E2, R2>(
+    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
     options?: { readonly bufferSize?: number | undefined } | undefined
-  ): <R>(self: GroupBy<R, E, K, V>) => Stream.Stream<A, E | E2, R2 | R>
-  <R, K, E, V, R2, E2, A>(
-    self: GroupBy<R, E, K, V>,
-    f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
+  ): <R>(self: GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>
+  <K, V, E, R, A, E2, R2>(
+    self: GroupBy<K, V, E, R>,
+    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
     options?: { readonly bufferSize?: number | undefined } | undefined
   ): Stream.Stream<A, E | E2, R | R2>
 } = internal.evaluate
@@ -77,8 +77,8 @@ export const evaluate: {
  * @category utils
  */
 export const filter: {
-  <K>(predicate: Predicate<NoInfer<K>>): <R, E, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
-  <R, E, V, K>(self: GroupBy<R, E, K, V>, predicate: Predicate<K>): GroupBy<R, E, K, V>
+  <K>(predicate: Predicate<NoInfer<K>>): <V, E, R>(self: GroupBy<K, V, E, R>) => GroupBy<K, V, E, R>
+  <K, V, E, R>(self: GroupBy<K, V, E, R>, predicate: Predicate<K>): GroupBy<K, V, E, R>
 } = internal.filter
 
 /**
@@ -88,8 +88,8 @@ export const filter: {
  * @category utils
  */
 export const first: {
-  (n: number): <R, E, K, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
-  <R, E, K, V>(self: GroupBy<R, E, K, V>, n: number): GroupBy<R, E, K, V>
+  (n: number): <K, V, E, R>(self: GroupBy<K, V, E, R>) => GroupBy<K, V, E, R>
+  <K, V, E, R>(self: GroupBy<K, V, E, R>, n: number): GroupBy<K, V, E, R>
 } = internal.first
 
 /**
@@ -98,6 +98,6 @@ export const first: {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <R, E, K, V>(
+export const make: <K, V, E, R>(
   grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
-) => GroupBy<R, E, K, V> = internal.make
+) => GroupBy<K, V, E, R> = internal.make

package/src/Layer.ts

@@ -252,7 +252,7 @@ export const effect: {
  * @since 2.0.0
  * @category constructors
  */
-export const effectDiscard: <_, E, R>(effect: Effect.Effect<_, E, R>) => Layer<never, E, R> = internal.fromEffectDiscard
+export const effectDiscard: <X, E, R>(effect: Effect.Effect<X, E, R>) => Layer<never, E, R> = internal.fromEffectDiscard
 
 /**
  * Constructs a layer from the specified effect, which must return one or more
@@ -323,10 +323,10 @@ export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Layer<unkn
  * @category sequencing
  */
 export const flatMap: {
-  <A, R2, E2, A2>(
+  <A, A2, E2, R2>(
     f: (context: Context.Context<A>) => Layer<A2, E2, R2>
-  ): <R, E>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
-  <R, E, A, R2, E2, A2>(
+  ): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
+  <A, E, R, A2, E2, R2>(
     self: Layer<A, E, R>,
     f: (context: Context.Context<A>) => Layer<A2, E2, R2>
   ): Layer<A2, E | E2, R | R2>
@@ -339,8 +339,8 @@ export const flatMap: {
  * @category sequencing
  */
 export const flatten: {
-  <R2, E2, A, I>(tag: Context.Tag<I, Layer<A, E2, R2>>): <R, E>(self: Layer<I, E, R>) => Layer<A, E2 | E, R2 | R>
-  <R, E, A, R2, E2, I>(self: Layer<I, E, R>, tag: Context.Tag<I, Layer<A, E2, R2>>): Layer<A, E | E2, R | R2>
+  <I, A, E2, R2>(tag: Context.Tag<I, Layer<A, E2, R2>>): <E, R>(self: Layer<I, E, R>) => Layer<A, E2 | E, R2 | R>
+  <I, E, R, A, E2, R2>(self: Layer<I, E, R>, tag: Context.Tag<I, Layer<A, E2, R2>>): Layer<A, E | E2, R | R2>
 } = internal.flatten
 
 /**
@@ -383,8 +383,8 @@ export const launch: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<
  * @category mapping
  */
 export const map: {
-  <A, B>(f: (context: Context.Context<A>) => Context.Context<B>): <R, E>(self: Layer<A, E, R>) => Layer<B, E, R>
-  <R, E, A, B>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Context.Context<B>): Layer<B, E, R>
+  <A, B>(f: (context: Context.Context<A>) => Context.Context<B>): <E, R>(self: Layer<A, E, R>) => Layer<B, E, R>
+  <A, E, R, B>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Context.Context<B>): Layer<B, E, R>
 } = internal.map
 
 /**
@@ -394,8 +394,8 @@ export const map: {
  * @category mapping
  */
 export const mapError: {
-  <E, E2>(f: (error: E) => E2): <R, A>(self: Layer<A, E, R>) => Layer<A, E2, R>
-  <R, E, A, E2>(self: Layer<A, E, R>, f: (error: E) => E2): Layer<A, E2, R>
+  <E, E2>(f: (error: E) => E2): <A, R>(self: Layer<A, E, R>) => Layer<A, E2, R>
+  <A, E, R, E2>(self: Layer<A, E, R>, f: (error: E) => E2): Layer<A, E2, R>
 } = internal.mapError
 
 /**
@@ -407,13 +407,13 @@ export const mapError: {
  * @category folding
  */
 export const match: {
-  <E, R2, E2, A2, A, R3, E3, A3>(
+  <E, A2, E2, R2, A, A3, E3, R3>(
     options: {
       readonly onFailure: (error: E) => Layer<A2, E2, R2>
       readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
     }
   ): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     self: Layer<A, E, R>,
     options: {
       readonly onFailure: (error: E) => Layer<A2, E2, R2>
@@ -431,13 +431,13 @@ export const match: {
  * @category folding
  */
 export const matchCause: {
-  <E, A, R2, E2, A2, R3, E3, A3>(
+  <E, A2, E2, R2, A, A3, E3, R3>(
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>
       readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
     }
   ): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     self: Layer<A, E, R>,
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>
@@ -504,8 +504,8 @@ export const orDie: <A, E, R>(self: Layer<A, E, R>) => Layer<A, never, R> = inte
  * @category error handling
  */
 export const orElse: {
-  <R2, E2, A2>(that: LazyArg<Layer<A2, E2, R2>>): <A, E, R>(self: Layer<A, E, R>) => Layer<A & A2, E2 | E, R2 | R>
-  <R, E, A, R2, E2, A2>(self: Layer<A, E, R>, that: LazyArg<Layer<A2, E2, R2>>): Layer<A & A2, E | E2, R | R2>
+  <A2, E2, R2>(that: LazyArg<Layer<A2, E2, R2>>): <A, E, R>(self: Layer<A, E, R>) => Layer<A & A2, E2 | E, R2 | R>
+  <A, E, R, A2, E2, R2>(self: Layer<A, E, R>, that: LazyArg<Layer<A2, E2, R2>>): Layer<A & A2, E | E2, R | R2>
 } = internal.orElse
 
 /**
@@ -561,7 +561,7 @@ export const locally: {
     ref: FiberRef<X>,
     value: X
   ): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  <R, E, A, X>(
+  <A, E, R, X>(
     self: Layer<A, E, R>,
     ref: FiberRef<X>,
     value: X
@@ -574,7 +574,7 @@ export const locally: {
  */
 export const locallyWith: {
   <X>(ref: FiberRef<X>, value: (_: X) => X): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
-  <R, E, A, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X): Layer<A, E, R>
+  <A, E, R, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X): Layer<A, E, R>
 } = internal.fiberRefLocallyWith
 
 /**
@@ -597,12 +597,12 @@ export const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) =>
  * @category retrying
  */
 export const retry: {
-  <RIn2, E, X>(
-    schedule: Schedule.Schedule<RIn2, E, X>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
-  <RIn, E, ROut, RIn2, X>(
+  <X, E, RIn2>(
+    schedule: Schedule.Schedule<X, E, RIn2>
+  ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
+  <ROut, E, RIn, X, RIn2>(
     self: Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<RIn2, E, X>
+    schedule: Schedule.Schedule<X, E, RIn2>
   ): Layer<ROut, E, RIn | RIn2>
 } = internal.retry
 
@@ -626,10 +626,10 @@ export const scope: Layer<Scope.CloseableScope> = internal.scope
 export const scoped: {
   <T extends Context.Tag<any, any>>(
     tag: T
-  ): <R, E>(
+  ): <E, R>(
     effect: Effect.Effect<Context.Tag.Service<T>, E, R>
   ) => Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
-  <T extends Context.Tag<any, any>, R, E>(
+  <T extends Context.Tag<any, any>, E, R>(
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E, R>
   ): Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
@@ -641,7 +641,7 @@ export const scoped: {
  * @since 2.0.0
  * @category constructors
  */
-export const scopedDiscard: <_, E, R>(effect: Effect.Effect<_, E, R>) => Layer<never, E, Exclude<R, Scope.Scope>> =
+export const scopedDiscard: <X, E, R>(effect: Effect.Effect<X, E, R>) => Layer<never, E, Exclude<R, Scope.Scope>> =
   internal.scopedDiscard
 
 /**
@@ -828,11 +828,11 @@ export const provideMerge: {
  * @category zipping
  */
 export const zipWith: {
-  <R2, E2, B, A, C>(
+  <B, E2, R2, A, C>(
     that: Layer<B, E2, R2>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ): <R, E>(self: Layer<A, E, R>) => Layer<C, E2 | E, R2 | R>
-  <R, E, R2, E2, B, A, C>(
+  ): <E, R>(self: Layer<A, E, R>) => Layer<C, E2 | E, R2 | R>
+  <A, E, R, B, E2, R2, C>(
     self: Layer<A, E, R>,
     that: Layer<B, E2, R2>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -843,14 +843,14 @@ export const zipWith: {
  * @since 2.0.0
  * @category utils
  */
-export const unwrapEffect: <R, E, R1, E1, A>(self: Effect.Effect<Layer<A, E1, R1>, E, R>) => Layer<A, E | E1, R | R1> =
+export const unwrapEffect: <A, E1, R1, E, R>(self: Effect.Effect<Layer<A, E1, R1>, E, R>) => Layer<A, E | E1, R | R1> =
   internal.unwrapEffect
 
 /**
  * @since 2.0.0
  * @category utils
  */
-export const unwrapScoped: <R, E, R1, E1, A>(
+export const unwrapScoped: <A, E1, R1, E, R>(
   self: Effect.Effect<Layer<A, E1, R1>, E, R>
 ) => Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> = internal.unwrapScoped
 
@@ -914,7 +914,7 @@ export const setRequestCache: {
   (
     cache: Request.Cache
   ): Layer<never>
-} = (<R, E>(cache: Request.Cache | Effect.Effect<Request.Cache, E, R>) =>
+} = (<E, R>(cache: Request.Cache | Effect.Effect<Request.Cache, E, R>) =>
   scopedDiscard(
     core.isEffect(cache) ?
       core.flatMap(cache, (x) => fiberRuntime.fiberRefLocallyScoped(query.currentCache as any, x)) :

package/src/List.ts

@@ -799,9 +799,9 @@ export const partition: {
  * @category combinators
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => [left: List<B>, right: List<C>]
-  <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [left: List<B>, right: List<C>]
-} = dual(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [left: List<B>, right: List<C>] => {
+  <A, B, C>(f: (a: A) => Either.Either<C, B>): (self: List<A>) => [left: List<B>, right: List<C>]
+  <A, B, C>(self: List<A>, f: (a: A) => Either.Either<C, B>): [left: List<B>, right: List<C>]
+} = dual(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<C, B>): [left: List<B>, right: List<C>] => {
   const left: Array<B> = []
   const right: Array<C> = []
   for (const a of self) {

package/src/Logger.ts

@@ -186,8 +186,8 @@ export const replace: {
  * @category context
  */
 export const replaceEffect: {
-  <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>
+  <B, E, R>(that: Effect<Logger<unknown, B>, E, R>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, R>
+  <A, B, E, R>(self: Logger<unknown, A>, that: Effect<Logger<unknown, B>, E, R>): Layer.Layer<never, E, R>
 } = circular.replaceLoggerEffect
 
 /**
@@ -195,10 +195,10 @@ export const replaceEffect: {
  * @category context
  */
 export const replaceScoped: {
-  <R, E, B>(
+  <B, E, R>(
     that: Effect<Logger<unknown, B>, E, R>
   ): <A>(self: Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: Logger<unknown, A>,
     that: Effect<Logger<unknown, B>, E, R>
   ): Layer.Layer<never, E, Exclude<R, Scope>>

package/src/Match.ts

@@ -57,7 +57,7 @@ export interface ValueMatcher<in Input, Filters, out Remaining, out Result, Prov
     readonly _result: Covariant<Result>
   }
   readonly provided: Provided
-  readonly value: Either.Either<Remaining, Provided>
+  readonly value: Either.Either<Provided, Remaining>
   add<I, R, RA, A, Pr>(_case: Case): ValueMatcher<I, R, RA, A, Pr>
 }
 
@@ -526,8 +526,8 @@ export const orElseAbsurd: <I, R, RA, A, Pr>(
  */
 export const either: <I, F, R, A, Pr>(
   self: Matcher<I, F, R, A, Pr>
-) => [Pr] extends [never] ? (input: I) => Either.Either<R, Unify<A>>
-  : Either.Either<R, Unify<A>> = internal.either
+) => [Pr] extends [never] ? (input: I) => Either.Either<Unify<A>, R>
+  : Either.Either<Unify<A>, R> = internal.either
 
 /**
  * @category conversions

package/src/MergeDecision.ts

@@ -61,7 +61,7 @@ export const Await: <R, E0, Z0, E, Z>(
  * @since 2.0.0
  * @category constructors
  */
-export const AwaitConst: <R, E, Z>(effect: Effect.Effect<Z, E, R>) => MergeDecision<R, unknown, unknown, E, Z> =
+export const AwaitConst: <Z, E, R>(effect: Effect.Effect<Z, E, R>) => MergeDecision<R, unknown, unknown, E, Z> =
   internal.AwaitConst
 
 /**

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<Either.Either<Done, Elem>, Err>
-  readonly right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+  readonly left: Fiber.Fiber<Either.Either<Elem, Done>, Err>
+  readonly right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
 }
 
 /**
@@ -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<Either.Either<Done, Elem>, Err>,
-  right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+  left: Fiber.Fiber<Either.Either<Elem, Done>, Err>,
+  right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
 ) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.BothRunning
 
 /**
@@ -151,8 +151,8 @@ export const match: {
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
-        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+        left: Fiber.Fiber<Either.Either<Elem, Done>, Err>,
+        right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
       ) => 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
@@ -162,8 +162,8 @@ export const match: {
     self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
-        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+        left: Fiber.Fiber<Either.Either<Elem, Done>, Err>,
+        right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
       ) => 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

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<A, E, R>): Effect.Effect<A, E, R>
+  <A extends In, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
 }
 
 /**
@@ -528,7 +528,7 @@ export const trackAll: {
  */
 export const trackDefect: {
   <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>
+  <A, E, R, Type, Out>(self: Effect.Effect<A, E, R>, metric: Metric<Type, unknown, Out>): Effect.Effect<A, E, R>
 } = internal.trackDefect
 
 /**
@@ -544,7 +544,7 @@ export const trackDefectWith: {
     metric: Metric<Type, In, Out>,
     f: (defect: unknown) => In
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A, Type, In, Out>(
+  <A, E, R, Type, In, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (defect: unknown) => In
@@ -563,7 +563,7 @@ export const trackDuration: {
   <Type, Out>(
     metric: Metric<Type, Duration.Duration, Out>
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A, Type, Out>(
+  <A, E, R, Type, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, Duration.Duration, Out>
   ): Effect.Effect<A, E, R>
@@ -582,7 +582,7 @@ export const trackDurationWith: {
     metric: Metric<Type, In, Out>,
     f: (duration: Duration.Duration) => In
   ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A, Type, In, Out>(
+  <A, E, R, Type, In, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (duration: Duration.Duration) => In
@@ -599,8 +599,8 @@ export const trackDurationWith: {
 export const trackError: {
   <Type, In, Out>(
     metric: Metric<Type, In, Out>
-  ): <R, E extends In, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E extends In, A, Type, In, Out>(
+  ): <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E extends In, R, Type, In, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>
   ): Effect.Effect<A, E, R>
@@ -618,8 +618,8 @@ export const trackErrorWith: {
   <Type, In, Out, In2>(
     metric: Metric<Type, In, Out>,
     f: (error: In2) => In
-  ): <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>(
+  ): <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E extends In2, R, Type, In, Out, In2>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (error: In2) => In
@@ -636,8 +636,8 @@ export const trackErrorWith: {
 export const trackSuccess: {
   <Type, In, Out>(
     metric: Metric<Type, In, Out>
-  ): <R, E, A extends In>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A extends In, Type, In, Out>(
+  ): <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A extends In, E, R, Type, In, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>
   ): Effect.Effect<A, E, R>
@@ -655,8 +655,8 @@ export const trackSuccessWith: {
   <Type, In, Out, In2>(
     metric: Metric<Type, In, Out>,
     f: (value: In2) => In
-  ): <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>(
+  ): <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A extends In2, E, R, Type, In, Out, In2>(
     self: Effect.Effect<A, E, R>,
     metric: Metric<Type, In, Out>,
     f: (value: In2) => In

package/src/MetricPolling.ts

@@ -70,14 +70,14 @@ export const collectAll: <R, E, Out>(
  * @category utils
  */
 export const launch: {
-  <R2, A2>(
-    schedule: Schedule.Schedule<R2, unknown, A2>
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ): <Type, In, R, E, Out>(
     self: MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R2 | R>
-  <Type, In, R, E, Out, R2, A2>(
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R2 | R | Scope.Scope>
+  <Type, In, R, E, Out, A2, R2>(
     self: MetricPolling<Type, In, R, E, Out>,
-    schedule: Schedule.Schedule<R2, unknown, A2>
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ): Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R | R2>
 } = internal.launch
 
@@ -108,12 +108,12 @@ export const pollAndUpdate: <Type, In, R, E, Out>(
  * @category constructors
  */
 export const retry: {
-  <R2, E, _>(
-    policy: Schedule.Schedule<R2, E, _>
+  <X, E, R2>(
+    policy: Schedule.Schedule<X, E, R2>
   ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
-  <Type, In, R, Out, R2, E, _>(
+  <Type, In, R, E, Out, X, R2>(
     self: MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<R2, E, _>
+    policy: Schedule.Schedule<X, E, R2>
   ): MetricPolling<Type, In, R | R2, E, Out>
 } = internal.retry
 

package/src/Number.ts

@@ -467,3 +467,29 @@ export const nextPow2 = (n: number): number => {
   const nextPow = Math.ceil(Math.log(n) / Math.log(2))
   return Math.max(Math.pow(2, nextPow), 2)
 }
+
+/**
+ * Tries to parse a `number` from a `string` using the `Number()` function.
+ * The following special string values are supported: "NaN", "Infinity", "-Infinity".
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const parse = (s: string): Option<number> => {
+  if (s === "NaN") {
+    return option.some(NaN)
+  }
+  if (s === "Infinity") {
+    return option.some(Infinity)
+  }
+  if (s === "-Infinity") {
+    return option.some(-Infinity)
+  }
+  if (s.trim() === "") {
+    return option.none
+  }
+  const n = Number(s)
+  return Number.isNaN(n)
+    ? option.none
+    : option.some(n)
+}