effect 2.4.19 → 3.0.0

package/src/Channel.ts

@@ -236,9 +236,9 @@ export const as: {
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+export const asVoid: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-) => Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> = channel.asUnit
+) => Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> = channel.asVoid
 
 /**
  * Creates a channel backed by a buffer. When the buffer is empty, the channel
@@ -2049,11 +2049,14 @@ export const toStream: <OutElem, OutErr, OutDone, Env>(
   self: Channel<Chunk.Chunk<OutElem>, unknown, OutErr, unknown, OutDone, unknown, Env>
 ) => Stream.Stream<OutElem, OutErr, Env> = stream.channelToStream
 
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Channel<never> = core.unit
+const void_: Channel<never> = core.void
+export {
+  /**
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Makes a channel from an effect that returns a channel in case of success.
@@ -2107,7 +2110,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined
@@ -2120,7 +2123,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined

package/src/Chunk.ts

@@ -1,6 +1,8 @@
 /**
  * @since 2.0.0
  */
+import * as RA from "./Array.js"
+import type { NonEmptyReadonlyArray } from "./Array.js"
 import type { Either } from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
@@ -15,9 +17,7 @@ import * as Order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.js"
-import * as RA from "./ReadonlyArray.js"
-import type { NonEmptyReadonlyArray } from "./ReadonlyArray.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant } from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/Chunk") as TypeId
 

package/src/ConfigError.ts

@@ -39,6 +39,7 @@ export declare namespace ConfigError {
    * @category models
    */
   export interface Proto {
+    readonly _tag: "ConfigError"
     readonly [ConfigErrorTypeId]: ConfigErrorTypeId
   }
 
@@ -72,7 +73,7 @@ export interface ConfigErrorReducer<in C, in out Z> {
  * @category models
  */
 export interface And extends ConfigError.Proto {
-  readonly _tag: "And"
+  readonly _op: "And"
   readonly left: ConfigError
   readonly right: ConfigError
 }
@@ -82,7 +83,7 @@ export interface And extends ConfigError.Proto {
  * @category models
  */
 export interface Or extends ConfigError.Proto {
-  readonly _tag: "Or"
+  readonly _op: "Or"
   readonly left: ConfigError
   readonly right: ConfigError
 }
@@ -92,7 +93,7 @@ export interface Or extends ConfigError.Proto {
  * @category models
  */
 export interface InvalidData extends ConfigError.Proto {
-  readonly _tag: "InvalidData"
+  readonly _op: "InvalidData"
   readonly path: Array<string>
   readonly message: string
 }
@@ -102,7 +103,7 @@ export interface InvalidData extends ConfigError.Proto {
  * @category models
  */
 export interface MissingData extends ConfigError.Proto {
-  readonly _tag: "MissingData"
+  readonly _op: "MissingData"
   readonly path: Array<string>
   readonly message: string
 }
@@ -112,7 +113,7 @@ export interface MissingData extends ConfigError.Proto {
  * @category models
  */
 export interface SourceUnavailable extends ConfigError.Proto {
-  readonly _tag: "SourceUnavailable"
+  readonly _op: "SourceUnavailable"
   readonly path: Array<string>
   readonly message: string
   readonly cause: Cause.Cause<unknown>
@@ -123,7 +124,7 @@ export interface SourceUnavailable extends ConfigError.Proto {
  * @category models
  */
 export interface Unsupported extends ConfigError.Proto {
-  readonly _tag: "Unsupported"
+  readonly _op: "Unsupported"
   readonly path: Array<string>
   readonly message: string
 }

package/src/Cron.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import * as Array from "./Array.js"
 import * as Either from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as equivalence from "./Equivalence.js"
@@ -10,7 +11,6 @@ import { format, type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
 import * as N from "./Number.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import { hasProperty } from "./Predicate.js"
-import * as ReadonlyArray from "./ReadonlyArray.js"
 import * as String from "./String.js"
 import type { Mutable } from "./Types.js"
 
@@ -46,11 +46,11 @@ const CronProto: Omit<Cron, "minutes" | "hours" | "days" | "months" | "weekdays"
   },
   [Hash.symbol](this: Cron): number {
     return pipe(
-      Hash.array(ReadonlyArray.fromIterable(this.minutes)),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.hours))),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.days))),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.months))),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.weekdays))),
+      Hash.array(Array.fromIterable(this.minutes)),
+      Hash.combine(Hash.array(Array.fromIterable(this.hours))),
+      Hash.combine(Hash.array(Array.fromIterable(this.days))),
+      Hash.combine(Hash.array(Array.fromIterable(this.months))),
+      Hash.combine(Hash.array(Array.fromIterable(this.weekdays))),
       Hash.cached(this)
     )
   },
@@ -60,11 +60,11 @@ const CronProto: Omit<Cron, "minutes" | "hours" | "days" | "months" | "weekdays"
   toJSON(this: Cron) {
     return {
       _id: "Cron",
-      minutes: ReadonlyArray.fromIterable(this.minutes),
-      hours: ReadonlyArray.fromIterable(this.hours),
-      days: ReadonlyArray.fromIterable(this.days),
-      months: ReadonlyArray.fromIterable(this.months),
-      weekdays: ReadonlyArray.fromIterable(this.weekdays)
+      minutes: Array.fromIterable(this.minutes),
+      hours: Array.fromIterable(this.hours),
+      days: Array.fromIterable(this.days),
+      months: Array.fromIterable(this.months),
+      weekdays: Array.fromIterable(this.weekdays)
     }
   },
   [NodeInspectSymbol](this: Cron) {
@@ -107,11 +107,11 @@ export const make = ({
   readonly weekdays: Iterable<number>
 }): Cron => {
   const o: Mutable<Cron> = Object.create(CronProto)
-  o.minutes = new Set(ReadonlyArray.sort(minutes, N.Order))
-  o.hours = new Set(ReadonlyArray.sort(hours, N.Order))
-  o.days = new Set(ReadonlyArray.sort(days, N.Order))
-  o.months = new Set(ReadonlyArray.sort(months, N.Order))
-  o.weekdays = new Set(ReadonlyArray.sort(weekdays, N.Order))
+  o.minutes = new Set(Array.sort(minutes, N.Order))
+  o.hours = new Set(Array.sort(hours, N.Order))
+  o.days = new Set(Array.sort(days, N.Order))
+  o.months = new Set(Array.sort(months, N.Order))
+  o.weekdays = new Set(Array.sort(weekdays, N.Order))
   return o
 }
 
@@ -364,7 +364,7 @@ export const Equivalence: equivalence.Equivalence<Cron> = equivalence.make((self
 
 const restrictionsArrayEquals = equivalence.array(equivalence.number)
 const restrictionsEquals = (self: ReadonlySet<number>, that: ReadonlySet<number>): boolean =>
-  restrictionsArrayEquals(ReadonlyArray.fromIterable(self), ReadonlyArray.fromIterable(that))
+  restrictionsArrayEquals(Array.fromIterable(self), Array.fromIterable(that))
 
 /**
  * Checks if two `Cron`s are equal.

package/src/Effect.ts

@@ -55,7 +55,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, Covariant, MergeRecord, NoInfer, NotFunction } from "./Types.js"
+import type { Concurrency, Covariant, MergeRecord, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 // -------------------------------------------------------------------------------------
@@ -1466,11 +1466,14 @@ export const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Effect<A, E
  */
 export const sync: <A>(evaluate: LazyArg<A>) => Effect<A> = core.sync
 
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Effect<void> = core.unit
+const _void: Effect<void> = core.void
+export {
+  /**
+   * @since 2.0.0
+   * @category constructors
+   */
+  _void as void
+}
 
 /**
  * @since 2.0.0
@@ -2103,7 +2106,7 @@ export const asSomeError: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Option.O
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R> = core.asUnit
+export const asVoid: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R> = core.asVoid
 
 /**
  * Returns an effect that swaps the error/success cases. This allows you to
@@ -3340,16 +3343,12 @@ export const option: <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>
 
 const if_: {
   <A1, E1, R1, A2, E2, R2>(
-    options: { readonly onTrue: Effect<A1, E1, R1>; readonly onFalse: Effect<A2, E2, R2> }
+    options: { readonly onTrue: LazyArg<Effect<A1, E1, R1>>; readonly onFalse: LazyArg<Effect<A2, E2, R2>> }
   ): <E = never, R = never>(self: boolean | Effect<boolean, E, R>) => Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
-  <A1, E1, R1, A2, E2, R2>(
-    self: boolean,
-    options: { readonly onTrue: Effect<A1, E1, R1>; readonly onFalse: Effect<A2, E2, R2> }
-  ): Effect<A1 | A2, E1 | E2, R1 | R2>
-  <E, R, A1, E1, R1, A2, E2, R2>(
-    self: Effect<boolean, E, R>,
-    options: { readonly onTrue: Effect<A1, E1, R1>; readonly onFalse: Effect<A2, E2, R2> }
-  ): Effect<A1 | A2, E | E1 | E2, R | R1 | R2>
+  <A1, E1, R1, A2, E2, R2, E = never, R = never>(
+    self: boolean | Effect<boolean, E, R>,
+    options: { readonly onTrue: LazyArg<Effect<A1, E1, R1>>; readonly onFalse: LazyArg<Effect<A2, E2, R2>> }
+  ): Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
 } = core.if_
 
 export {
@@ -4340,10 +4339,18 @@ export const matchEffect: {
  * @since 2.0.0
  * @category logging
  */
-export const log: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.log
+export const log: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.log
+
+/**
+ * Logs the specified message or cause at the specified log level.
+ *
+ * @since 2.0.0
+ * @category logging
+ */
+export const logWithLevel = (
+  level: LogLevel,
+  ...message: ReadonlyArray<any>
+): Effect<void> => effect.logWithLevel(level)(...message)
 
 /**
  * Logs the specified message or cause at the Trace log level.
@@ -4351,10 +4358,7 @@ export const log: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logTrace: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logTrace
+export const logTrace: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logTrace
 
 /**
  * Logs the specified message or cause at the Debug log level.
@@ -4362,10 +4366,7 @@ export const logTrace: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logDebug: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logDebug
+export const logDebug: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logDebug
 
 /**
  * Logs the specified message or cause at the Info log level.
@@ -4373,10 +4374,7 @@ export const logDebug: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logInfo: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logInfo
+export const logInfo: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logInfo
 
 /**
  * Logs the specified message or cause at the Warning log level.
@@ -4384,10 +4382,7 @@ export const logInfo: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logWarning: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logWarning
+export const logWarning: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logWarning
 
 /**
  * Logs the specified message or cause at the Error log level.
@@ -4395,10 +4390,7 @@ export const logWarning: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logError: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logError
+export const logError: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logError
 
 /**
  * Logs the specified message or cause at the Fatal log level.
@@ -4406,10 +4398,7 @@ export const logError: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logFatal: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logFatal
+export const logFatal: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logFatal
 
 /**
  * Adjusts the label for the current logging span.
@@ -5140,7 +5129,7 @@ export const currentSpan: Effect<Tracer.Span, Cause.NoSuchElementException> = ef
  * @since 2.0.0
  * @category tracing
  */
-export const currentParentSpan: Effect<Tracer.ParentSpan, Cause.NoSuchElementException> = effect.currentParentSpan
+export const currentParentSpan: Effect<Tracer.AnySpan, Cause.NoSuchElementException> = effect.currentParentSpan
 
 /**
  * @since 2.0.0
@@ -5162,12 +5151,12 @@ export const spanLinks: Effect<Chunk.Chunk<Tracer.SpanLink>> = effect.spanLinks
  */
 export const linkSpans: {
   (
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
   <A, E, R>(
     self: Effect<A, E, R>,
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ): Effect<A, E, R>
 } = effect.linkSpans
@@ -5183,7 +5172,7 @@ export const makeSpan: (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }
@@ -5204,10 +5193,10 @@ export const makeSpanScoped: (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
-  }
+  } | undefined
 ) => Effect<Tracer.Span, never, Scope.Scope> = fiberRuntime.makeSpanScoped
 
 /**
@@ -5227,7 +5216,7 @@ export const useSpan: {
     options: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     },
@@ -5247,7 +5236,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined
@@ -5258,7 +5247,7 @@ export const withSpan: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     } | undefined
@@ -5279,7 +5268,7 @@ export const withSpanScoped: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     }
@@ -5290,7 +5279,7 @@ export const withSpanScoped: {
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     }
@@ -5304,8 +5293,8 @@ export const withSpanScoped: {
  * @category tracing
  */
 export const withParentSpan: {
-  (span: Tracer.ParentSpan): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>
-  <A, E, R>(self: Effect<A, E, R>, span: Tracer.ParentSpan): Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  (span: Tracer.AnySpan): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(self: Effect<A, E, R>, span: Tracer.AnySpan): Effect<A, E, Exclude<R, Tracer.ParentSpan>>
 } = effect.withParentSpan
 
 // -------------------------------------------------------------------------------------

package/src/Either.ts

@@ -12,7 +12,7 @@ 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 { Covariant, MergeRecord, NoInfer, NotFunction } from "./Types.js"
+import type { Covariant, MergeRecord, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -287,15 +287,15 @@ export const getLeft: <R, L>(self: Either<R, L>) => Option<L> = either.getLeft
  * @category equivalence
  * @since 2.0.0
  */
-export const getEquivalence = <R, L>(
-  EquivalenceL: Equivalence.Equivalence<L>,
-  EquivalenceR: Equivalence.Equivalence<R>
-): Equivalence.Equivalence<Either<R, L>> =>
+export const getEquivalence = <R, L>({ left, right }: {
+  right: Equivalence.Equivalence<R>
+  left: Equivalence.Equivalence<L>
+}): Equivalence.Equivalence<Either<R, L>> =>
   Equivalence.make((x, y) =>
     x === y ||
     (isLeft(x) ?
-      isLeft(y) && EquivalenceL(x.left, y.left) :
-      isRight(y) && EquivalenceR(x.right, y.right))
+      isLeft(y) && left(x.left, y.left) :
+      isRight(y) && right(x.right, y.right))
   )
 
 /**

package/src/ExecutionStrategy.ts

@@ -106,6 +106,14 @@ export const isParallelN: (self: ExecutionStrategy) => self is ParallelN = inter
  * @category folding
  */
 export const match: {
-  <A>(onSequential: LazyArg<A>, onParallel: LazyArg<A>, onParallelN: (n: number) => A): (self: ExecutionStrategy) => A
-  <A>(self: ExecutionStrategy, onSequential: LazyArg<A>, onParallel: LazyArg<A>, onParallelN: (n: number) => A): A
+  <A>(options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }): (self: ExecutionStrategy) => A
+  <A>(self: ExecutionStrategy, options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }): A
 } = internal.match

package/src/Exit.ts

@@ -10,7 +10,6 @@ import * as core from "./internal/core.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -128,7 +127,7 @@ export const as: {
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <A, E>(self: Exit<A, E>) => Exit<void, E> = core.exitAsUnit
+export const asVoid: <A, E>(self: Exit<A, E>) => Exit<void, E> = core.exitAsVoid
 
 /**
  * Returns a `Some<Cause<E>>` if the specified exit is a `Failure`, `None`
@@ -358,13 +357,16 @@ export const matchEffect: {
  */
 export const succeed: <A>(value: A) => Exit<A> = core.exitSucceed
 
-/**
- * Represents an `Exit` which succeeds with `undefined`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Exit<void> = core.exitUnit
+const void_: Exit<void> = core.exitVoid
+export {
+  /**
+   * Represents an `Exit` which succeeds with `undefined`.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Sequentially zips the this result with the specified result or else returns

package/src/Fiber.ts

@@ -451,7 +451,7 @@ export const join: <A, E>(self: Fiber<A, E>) => Effect.Effect<A, E> = internal.j
  * @since 2.0.0
  * @category destructors
  */
-export const joinAll: <A, E>(fibers: Iterable<Fiber<A, E>>) => Effect.Effect<void, E> = fiberRuntime.fiberJoinAll
+export const joinAll: <A, E>(fibers: Iterable<Fiber<A, E>>) => Effect.Effect<Array<A>, E> = fiberRuntime.fiberJoinAll
 
 /**
  * Maps over the value the Fiber computes.
@@ -602,13 +602,16 @@ export const status: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<FiberStat
  */
 export const succeed: <A>(value: A) => Fiber<A> = internal.succeed
 
-/**
- * A fiber that has already succeeded with unit.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Fiber<void> = internal.unit
+const void_: Fiber<void> = internal.void
+export {
+  /**
+   * A fiber that has already succeeded with unit.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Zips this fiber and the specified fiber together, producing a tuple of