effect 2.0.0-next.56 → 2.0.0-next.57

package/src/Config.ts

@@ -13,6 +13,7 @@ import type * as LogLevel from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -44,7 +45,7 @@ export declare namespace Config {
    */
   export interface Variance<out A> {
     readonly [ConfigTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Covariant<A>
     }
   }
 
@@ -100,7 +101,7 @@ export const all: <const Arg extends Iterable<Config<any>> | Record<string, Conf
  * @since 2.0.0
  * @category constructors
  */
-export const array: <A>(config: Config<A>, name?: string | undefined) => Config<ReadonlyArray<A>> = internal.array
+export const array: <A>(config: Config<A>, name?: string) => Config<ReadonlyArray<A>> = internal.array
 
 /**
  * Constructs a config for a boolean value.
@@ -108,7 +109,7 @@ export const array: <A>(config: Config<A>, name?: string | undefined) => Config<
  * @since 2.0.0
  * @category constructors
  */
-export const boolean: (name?: string | undefined) => Config<boolean> = internal.boolean
+export const boolean: (name?: string) => Config<boolean> = internal.boolean
 
 /**
  * Constructs a config for a sequence of values.
@@ -116,7 +117,7 @@ export const boolean: (name?: string | undefined) => Config<boolean> = internal.
  * @since 2.0.0
  * @category constructors
  */
-export const chunk: <A>(config: Config<A>, name?: string | undefined) => Config<Chunk.Chunk<A>> = internal.chunk
+export const chunk: <A>(config: Config<A>, name?: string) => Config<Chunk.Chunk<A>> = internal.chunk
 
 /**
  * Constructs a config for a date value.
@@ -124,7 +125,7 @@ export const chunk: <A>(config: Config<A>, name?: string | undefined) => Config<
  * @since 2.0.0
  * @category constructors
  */
-export const date: (name?: string | undefined) => Config<Date> = internal.date
+export const date: (name?: string) => Config<Date> = internal.date
 
 /**
  * Constructs a config that fails with the specified message.
@@ -140,7 +141,7 @@ export const fail: (message: string) => Config<never> = internal.fail
  * @since 2.0.0
  * @category constructors
  */
-export const number: (name?: string | undefined) => Config<number> = internal.number
+export const number: (name?: string) => Config<number> = internal.number
 
 /**
  * Constructs a config for a integer value.
@@ -148,7 +149,7 @@ export const number: (name?: string | undefined) => Config<number> = internal.nu
  * @since 2.0.0
  * @category constructors
  */
-export const integer: (name?: string | undefined) => Config<number> = internal.integer
+export const integer: (name?: string) => Config<number> = internal.integer
 
 /**
  * Constructs a config for a `LogLevel` value.
@@ -156,7 +157,7 @@ export const integer: (name?: string | undefined) => Config<number> = internal.i
  * @since 2.0.0
  * @category constructors
  */
-export const logLevel: (name?: string | undefined) => Config<LogLevel.LogLevel> = internal.logLevel
+export const logLevel: (name?: string) => Config<LogLevel.LogLevel> = internal.logLevel
 
 /**
  * This function returns `true` if the specified value is an `Config` value,
@@ -182,7 +183,7 @@ export const isConfig: (u: unknown) => u is Config<unknown> = internal.isConfig
  * a different value, constructed using the specified function.
  *
  * @since 2.0.0
- * @category utils
+ * @category mapping
  */
 export const map: {
   <A, B>(f: (a: A) => B): (self: Config<A>) => Config<B>
@@ -299,7 +300,7 @@ export const repeat: <A>(self: Config<A>) => Config<Array<A>> = internal.repeat
  * @since 2.0.0
  * @category constructors
  */
-export const secret: (name?: string | undefined) => Config<ConfigSecret.ConfigSecret> = internal.secret
+export const secret: (name?: string) => Config<ConfigSecret.ConfigSecret> = internal.secret
 
 /**
  * Constructs a config for a sequence of values.
@@ -307,7 +308,7 @@ export const secret: (name?: string | undefined) => Config<ConfigSecret.ConfigSe
  * @since 2.0.0
  * @category constructors
  */
-export const hashSet: <A>(config: Config<A>, name?: string | undefined) => Config<HashSet.HashSet<A>> = internal.hashSet
+export const hashSet: <A>(config: Config<A>, name?: string) => Config<HashSet.HashSet<A>> = internal.hashSet
 
 /**
  * Constructs a config for a string value.
@@ -315,7 +316,7 @@ export const hashSet: <A>(config: Config<A>, name?: string | undefined) => Confi
  * @since 2.0.0
  * @category constructors
  */
-export const string: (name?: string | undefined) => Config<string> = internal.string
+export const string: (name?: string) => Config<string> = internal.string
 
 /**
  * Constructs a config which contains the specified value.
@@ -347,8 +348,7 @@ export const sync: <A>(value: LazyArg<A>) => Config<A> = internal.sync
  * @since 2.0.0
  * @category constructors
  */
-export const hashMap: <A>(config: Config<A>, name?: string | undefined) => Config<HashMap.HashMap<string, A>> =
-  internal.hashMap
+export const hashMap: <A>(config: Config<A>, name?: string) => Config<HashMap.HashMap<string, A>> = internal.hashMap
 
 /**
  * Constructs a config from some configuration wrapped with the `Wrap<A>` utility type.
@@ -427,7 +427,7 @@ export const withDescription: {
  * config.
  *
  * @since 2.0.0
- * @category utils
+ * @category zipping
  */
 export const zip: {
   <B>(that: Config<B>): <A>(self: Config<A>) => Config<[A, B]>
@@ -439,7 +439,7 @@ export const zip: {
  * using the provided function.
  *
  * @since 2.0.0
- * @category utils
+ * @category zipping
  */
 export const zipWith: {
   <B, A, C>(that: Config<B>, f: (a: A, b: B) => C): (self: Config<A>) => Config<C>

package/src/Context.ts

@@ -12,6 +12,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as internal from "./internal/context.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 const TagTypeId: unique symbol = internal.TagTypeId
@@ -30,8 +31,8 @@ export interface Tag<in out Identifier, in out Service> extends Pipeable, Inspec
   readonly _tag: "Tag"
   readonly _op: "Tag"
   readonly [TagTypeId]: {
-    readonly _S: (_: Service) => Service
-    readonly _I: (_: Identifier) => Identifier
+    readonly _Service: Types.Invariant<Service>
+    readonly _Identifier: Types.Invariant<Identifier>
   }
   of(self: Service): Service
   context(self: Service): Context<Identifier>
@@ -113,7 +114,7 @@ export type ValidTagsById<R> = R extends infer S ? Tag<S, any> : never
  */
 export interface Context<in Services> extends Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _S: (_: Services) => unknown
+    readonly _Services: Types.Contravariant<Services>
   }
   readonly unsafeMap: Map<Tag<any, any>, any>
 }

package/src/Data.ts

@@ -207,7 +207,7 @@ export const tagged = <A extends Case & { readonly _tag: string }>(
  * @since 2.0.0
  * @category constructors
  */
-export const Class: new<A extends Record<string, any>>(
+export const Class: new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
 ) => Data<Readonly<A>> = internal.Structural as any
@@ -237,7 +237,7 @@ export const Class: new<A extends Record<string, any>>(
  */
 export const TaggedClass = <Tag extends string>(
   tag: Tag
-): new<A extends Record<string, any>>(
+): new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Equal.Equal ? never : P]: A[P] }
 ) => Data<Readonly<A> & { readonly _tag: Tag }> => {
@@ -446,7 +446,7 @@ export const taggedEnum: {
  * @since 2.0.0
  * @category constructors
  */
-export const Error: new<A extends Record<string, any>>(
+export const Error: new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
 ) => Cause.YieldableError & Readonly<A> = (function() {
@@ -464,7 +464,7 @@ export const Error: new<A extends Record<string, any>>(
  * @since 2.0.0
  * @category constructors
  */
-export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any>>(
+export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any> = {}>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
     : { readonly [P in keyof A as P extends "_tag" | keyof Equal.Equal ? never : P]: A[P] }
 ) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A> => {

package/src/Deferred.ts

@@ -11,6 +11,7 @@ import * as internal from "./internal/deferred.js"
 import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -53,8 +54,8 @@ export declare namespace Deferred {
    */
   export interface Variance<in out E, in out A> {
     readonly [DeferredTypeId]: {
-      readonly _E: (_: E) => E
-      readonly _A: (_: A) => A
+      readonly _E: Types.Invariant<E>
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Differ.ts

@@ -14,6 +14,7 @@ import * as ContextPatch from "./internal/differ/contextPatch.js"
 import * as HashMapPatch from "./internal/differ/hashMapPatch.js"
 import * as HashSetPatch from "./internal/differ/hashSetPatch.js"
 import * as OrPatch from "./internal/differ/orPatch.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -48,8 +49,8 @@ export type TypeId = typeof TypeId
  */
 export interface Differ<in out Value, in out Patch> {
   readonly [TypeId]: {
-    readonly _V: (_: Value) => Value
-    readonly _P: (_: Patch) => Patch
+    readonly _V: Types.Invariant<Value>
+    readonly _P: Types.Invariant<Patch>
   }
   readonly empty: Patch
   diff(oldValue: Value, newValue: Value): Patch
@@ -86,8 +87,8 @@ export declare namespace Differ {
      */
     export interface Patch<in Input, out Output> extends Equal {
       readonly [ContextPatchTypeId]: {
-        readonly _Input: (_: Input) => void
-        readonly _Output: (_: never) => Output
+        readonly _Input: Types.Contravariant<Input>
+        readonly _Output: Types.Covariant<Output>
       }
     }
   }
@@ -109,8 +110,8 @@ export declare namespace Differ {
      */
     export interface Patch<in out Value, in out Patch> extends Equal {
       readonly [ChunkPatchTypeId]: {
-        readonly _Value: (_: Value) => Value
-        readonly _Patch: (_: Patch) => Patch
+        readonly _Value: Types.Invariant<Value>
+        readonly _Patch: Types.Invariant<Patch>
       }
     }
   }
@@ -132,9 +133,9 @@ export declare namespace Differ {
      */
     export interface Patch<in out Key, in out Value, in out Patch> extends Equal {
       readonly [HashMapPatchTypeId]: {
-        readonly _Key: (_: Key) => Key
-        readonly _Value: (_: Value) => Value
-        readonly _Patch: (_: Patch) => Patch
+        readonly _Key: Types.Invariant<Key>
+        readonly _Value: Types.Invariant<Value>
+        readonly _Patch: Types.Invariant<Patch>
       }
     }
   }
@@ -156,7 +157,7 @@ export declare namespace Differ {
      */
     export interface Patch<in out Value> extends Equal {
       readonly [HashSetPatchTypeId]: {
-        readonly _Value: (_: Value) => Value
+        readonly _Value: Types.Invariant<Value>
       }
     }
   }
@@ -178,10 +179,10 @@ export declare namespace Differ {
      */
     export interface Patch<in out Value, in out Value2, in out Patch, in out Patch2> extends Equal {
       readonly [OrPatchTypeId]: {
-        readonly _Value: (_: Value) => Value
-        readonly _Value2: (_: Value2) => Value2
-        readonly _Patch: (_: Patch) => Patch
-        readonly _Patch2: (_: Patch2) => Patch2
+        readonly _Value: Types.Invariant<Value>
+        readonly _Value2: Types.Invariant<Value2>
+        readonly _Patch: Types.Invariant<Patch>
+        readonly _Patch2: Types.Invariant<Patch2>
       }
     }
   }

package/src/Duration.ts

@@ -6,7 +6,7 @@ import type * as equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { Inspectable } from "./Inspectable.js"
-import { NodeInspectSymbol, toString } from "./Inspectable.js"
+import { NodeInspectSymbol } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
@@ -123,7 +123,7 @@ const DurationProto: Omit<Duration, "value"> = {
     return isDuration(that) && equals(this, that)
   },
   toString(this: Duration) {
-    return toString(this.toJSON())
+    return `Duration(${format(this)})`
   },
   toJSON(this: Duration) {
     switch (this.value._tag) {
@@ -588,3 +588,55 @@ export const equals: {
   (that: DurationInput): (self: DurationInput) => boolean
   (self: DurationInput, that: DurationInput): boolean
 } = dual(2, (self: DurationInput, that: DurationInput): boolean => Equivalence(decode(self), decode(that)))
+
+/**
+ * Converts a `Duration` to a human readable string.
+ * @since 2.0.0
+ *
+ * @example
+ * import * as Duration from "effect/Duration"
+ *
+ * Duration.format(Duration.millis(1000)) // "1s"
+ * Duration.format(Duration.millis(1001)) // "1s 1ms"
+ */
+export const format = (self: DurationInput): string => {
+  const duration = decode(self)
+  const parts = []
+
+  if (duration.value._tag === "Infinity") {
+    return "Infinity"
+  }
+
+  const nanos = unsafeToNanos(duration)
+
+  if (nanos % 1000000n) {
+    parts.push(`${nanos % 1000000n}ns`)
+  }
+
+  const ms = nanos / 1000000n
+  if (ms % 1000n !== 0n) {
+    parts.push(`${ms % 1000n}ms`)
+  }
+
+  const sec = ms / 1000n
+  if (sec % 60n !== 0n) {
+    parts.push(`${sec % 60n}s`)
+  }
+
+  const min = sec / 60n
+  if (min % 60n !== 0n) {
+    parts.push(`${min % 60n}m`)
+  }
+
+  const hr = min / 60n
+  if (hr % 24n !== 0n) {
+    parts.push(`${hr % 24n}h`)
+  }
+
+  const days = hr / 24n
+  if (days !== 0n) {
+    parts.push(`${days}d`)
+  }
+
+  return parts.reverse().join(" ")
+}

package/src/Effect.ts

@@ -54,7 +54,7 @@ import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Supervisor from "./Supervisor.js"
 import type * as Tracer from "./Tracer.js"
-import type { Concurrency, NoInfer } from "./Types.js"
+import type { Concurrency, Covariant, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 // -------------------------------------------------------------------------------------
@@ -137,10 +137,10 @@ export interface EffectTypeLambda extends TypeLambda {
  * @since 2.0.0
  * @category models
  */
-export interface Blocked<out R, out E, out A> extends Effect<R, E, A> {
+export interface Blocked<out E, out A> extends Effect<never, E, A> {
   readonly _op: "Blocked"
-  readonly i0: RequestBlock<R>
-  readonly i1: Effect<R, E, A>
+  readonly i0: RequestBlock
+  readonly i1: Effect<never, E, A>
 }
 
 /**
@@ -209,9 +209,9 @@ export declare namespace Effect {
    */
   export interface VarianceStruct<out R, out E, out A> {
     readonly _V: string
-    readonly _R: (_: never) => R
-    readonly _E: (_: never) => E
-    readonly _A: (_: never) => A
+    readonly _R: Covariant<R>
+    readonly _E: Covariant<E>
+    readonly _A: Covariant<A>
   }
   /**
    * @since 2.0.0
@@ -1512,7 +1512,7 @@ export const catchAll: {
 /**
  * Recovers from both recoverable and unrecoverable errors.
  *
- * See `absorb`, `sandbox`, `mapErrorCause` for other functions that can
+ * See `sandbox`, `mapErrorCause` for other functions that can
  * recover from defects.
  *
  * @since 2.0.0
@@ -1656,10 +1656,9 @@ export const catchTag: {
 export const catchTags: {
   <
     E,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & { [K in Extract<E, { _tag: string }>["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
+      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
   >(
     cases: Cases
   ): <R, A>(
@@ -1682,10 +1681,9 @@ export const catchTags: {
     R,
     E,
     A,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & { [K in Extract<E, { _tag: string }>["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
+      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
   >(
     self: Effect<R, E, A>,
     cases: Cases
@@ -2201,7 +2199,7 @@ export const mapError: {
  * function. This can be used to transform errors while preserving the
  * original structure of `Cause`.
  *
- * See `absorb`, `sandbox`, `catchAllCause` for other functions for dealing
+ * See `sandbox`, `catchAllCause` for other functions for dealing
  * with defects.
  *
  * @since 2.0.0
@@ -4882,29 +4880,20 @@ export const ap: {
  * @category requests & batching
  * @since 2.0.0
  */
-export const blocked: <R, E, A>(blockedRequests: RequestBlock<R>, _continue: Effect<R, E, A>) => Blocked<R, E, A> =
+export const blocked: <E, A>(blockedRequests: RequestBlock, _continue: Effect<never, E, A>) => Blocked<E, A> =
   core.blocked
 
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export const runRequestBlock: <R>(blockedRequests: RequestBlock<R>) => Blocked<R, never, void> = core.runRequestBlock
+export const runRequestBlock: <R>(blockedRequests: RequestBlock) => Effect<R, never, void> = core.runRequestBlock
 
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export const step: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Exit.Exit<E, A> | Blocked<R, E, A>> = core.step
-
-/**
- * @category requests & batching
- * @since 2.0.0
- */
-export const flatMapStep: <R, E, A, R1, E1, B>(
-  self: Effect<R, E, A>,
-  f: (step: Exit.Exit<E, A> | Blocked<R, E, A>) => Effect<R1, E1, B>
-) => Effect<R | R1, E1, B> = core.flatMapStep
+export const step: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Exit.Exit<E, A> | Blocked<E, A>> = core.step
 
 /**
  * @since 2.0.0

package/src/Either.ts

@@ -11,7 +11,9 @@ import type { Inspectable } from "./Inspectable.js"
 import * as either from "./internal/either.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type { Predicate, Refinement } from "./Predicate.js"
 import { isFunction } from "./Predicate.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -42,8 +44,8 @@ export interface Left<out E, out A> extends Data.Case, Pipeable, Inspectable {
   readonly _op: "Left"
   readonly left: E
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
-    readonly _E: (_: never) => E
+    readonly _A: Types.Covariant<A>
+    readonly _E: Types.Covariant<E>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: EitherUnify<this>
@@ -59,8 +61,8 @@ export interface Right<out E, out A> extends Data.Case, Pipeable, Inspectable {
   readonly _op: "Right"
   readonly right: A
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
-    readonly _E: (_: never) => E
+    readonly _A: Types.Covariant<A>
+    readonly _E: Types.Covariant<E>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: EitherUnify<this>
@@ -374,6 +376,59 @@ export const match: {
   }): B | C => isLeft(self) ? onLeft(self.left) : onRight(self.right)
 )
 
+/**
+ * Filter the right value with the provided function.
+ * If the predicate fails, set the left value with the result of the provided function.
+ *
+ * @example
+ * import * as E from 'effect/Either'
+ * import { pipe } from 'effect/Function'
+ *
+ * const isPositive = (n: number): boolean => n > 0
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     E.right(1),
+ *     E.filterOrLeft(isPositive, n => `${n} is not positive`)
+ *   ),
+ *   E.right(1)
+ * )
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     E.right(0),
+ *     E.filterOrLeft(isPositive, n => `${n} is not positive`)
+ *   ),
+ *   E.left("0 is not positive")
+ * )
+ *
+ * @since 2.0.0
+ * @category filtering & conditionals
+ */
+export const filterOrLeft: {
+  <A, B extends A, X extends A, E2>(
+    filter: Refinement<A, B>,
+    orLeftWith: (a: X) => E2
+  ): <E>(self: Either<E, A>) => Either<E2 | E, B>
+  <A, X extends A, Y extends A, E2>(
+    filter: Predicate<X>,
+    orLeftWith: (a: Y) => E2
+  ): <E>(self: Either<E, A>) => Either<E2 | E, A>
+  <E, A, B extends A, X extends A, E2>(
+    self: Either<E, A>,
+    filter: Refinement<A, B>,
+    orLeftWith: (a: X) => E2
+  ): Either<E | E2, B>
+  <E, A, X extends A, Y extends A, E2>(
+    self: Either<E, A>,
+    filter: Predicate<X>,
+    orLeftWith: (a: Y) => E2
+  ): Either<E | E2, A>
+} = dual(3, <E, A, E2>(
+  self: Either<E, A>,
+  filter: Predicate<A>,
+  orLeftWith: (a: A) => E2
+): Either<E | E2, A> => flatMap(self, (a) => filter(a) ? right(a) : left(orLeftWith(a))))
+
 /**
  * @category getters
  * @since 2.0.0
@@ -527,8 +582,8 @@ export const andThen: {
 )
 
 /**
+ * @category zipping
  * @since 2.0.0
- * @category combining
  */
 export const zipWith: {
   <E2, A2, A, B>(
@@ -560,13 +615,13 @@ export const ap: {
 )
 
 /**
- * Takes a structure of `Option`s and returns an `Option` of values with the same structure.
+ * Takes a structure of `Either`s and returns an `Either` of values with the same structure.
  *
- * - If a tuple is supplied, then the returned `Option` will contain a tuple with the same length.
- * - If a struct is supplied, then the returned `Option` will contain a struct with the same keys.
- * - If an iterable is supplied, then the returned `Option` will contain an array.
+ * - If a tuple is supplied, then the returned `Either` will contain a tuple with the same length.
+ * - If a struct is supplied, then the returned `Either` will contain a struct with the same keys.
+ * - If an iterable is supplied, then the returned `Either` will contain an array.
  *
- * @param fields - the struct of `Option`s to be sequenced.
+ * @param fields - the struct of `Either`s to be sequenced.
  *
  * @example
  * import * as Either from "effect/Either"

package/src/Equivalence.ts

@@ -110,7 +110,7 @@ export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence
   combineMany(isAlwaysEquivalent, collection)
 
 /**
- * @category combinators
+ * @category mapping
  * @since 2.0.0
  */
 export const mapInput: {

package/src/Fiber.ts

@@ -19,6 +19,7 @@ import type * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as RuntimeFlags from "./RuntimeFlags.js"
 import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -165,8 +166,8 @@ export declare namespace Fiber {
    */
   export interface Variance<out E, out A> {
     readonly [FiberTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 
@@ -175,8 +176,8 @@ export declare namespace Fiber {
    */
   export interface RuntimeVariance<out E, out A> {
     readonly [RuntimeFiberTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 

package/src/FiberRef.ts

@@ -25,6 +25,7 @@ import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Supervisor from "./Supervisor.js"
 import type * as Tracer from "./Tracer.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -63,7 +64,7 @@ export interface FiberRef<in out A> extends Variance<A>, Pipeable {
  */
 export interface Variance<in out A> {
   readonly [FiberRefTypeId]: {
-    readonly _A: (_: A) => A
+    readonly _A: Types.Invariant<A>
   }
 }
 
@@ -270,6 +271,12 @@ export const updateSomeAndGet: {
   <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
 } = core.fiberRefUpdateSomeAndGet
 
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+export const currentConcurrency: FiberRef<number | "unbounded"> = core.currentConcurrency
+
 /**
  * @since 2.0.0
  * @category fiberRefs