effect 2.0.0-next.55 → 2.0.0-next.56

package/src/ChildExecutorDecision.ts

@@ -129,10 +129,18 @@ export const isYield: (self: ChildExecutorDecision) => self is Yield = internal.
  */
 export const match: {
   <A>(
-    options: { readonly onContinue: () => A; readonly onClose: (value: unknown) => A; readonly onYield: () => A }
+    options: {
+      readonly onContinue: () => A
+      readonly onClose: (value: unknown) => A
+      readonly onYield: () => A
+    }
   ): (self: ChildExecutorDecision) => A
   <A>(
     self: ChildExecutorDecision,
-    options: { readonly onContinue: () => A; readonly onClose: (value: unknown) => A; readonly onYield: () => A }
+    options: {
+      readonly onContinue: () => A
+      readonly onClose: (value: unknown) => A
+      readonly onYield: () => A
+    }
   ): A
 } = internal.match

package/src/Chunk.ts

@@ -30,7 +30,7 @@ export type TypeId = typeof TypeId
  * @category models
  * @since 2.0.0
  */
-export interface Chunk<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+export interface Chunk<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
     readonly _A: (_: never) => A
   }
@@ -49,7 +49,7 @@ export interface Chunk<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectabl
  * @category model
  * @since 2.0.0
  */
-export interface NonEmptyChunk<A> extends Chunk<A>, NonEmptyIterable<A> {}
+export interface NonEmptyChunk<out A> extends Chunk<A>, NonEmptyIterable<A> {}
 
 /**
  * @category type lambdas
@@ -533,13 +533,13 @@ export const dropRight: {
  * @since 2.0.0
  */
 export const dropWhile: {
-  <A>(f: (a: A) => boolean): (self: Chunk<A>) => Chunk<A>
-  <A>(self: Chunk<A>, f: (a: A) => boolean): Chunk<A>
-} = dual(2, <A>(self: Chunk<A>, f: (a: A) => boolean): Chunk<A> => {
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>
+} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A> => {
   const arr = toReadonlyArray(self)
   const len = arr.length
   let i = 0
-  while (i < len && f(arr[i]!)) {
+  while (i < len && predicate(arr[i]!)) {
     i++
   }
   return drop(self, i)
@@ -647,13 +647,13 @@ export const filterMap: {
  * @category filtering
  */
 export const filter: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Chunk<B>
   <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
-  <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): Chunk<B>
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): Chunk<B>
+  <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>
 } = dual(
   2,
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>) =>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A> =>
     unsafeFromArray(RA.filterMap(self, O.liftPredicate(predicate)))
 )
 
@@ -881,13 +881,20 @@ export const mapAccum: {
  * @since 2.0.0
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => [Chunk<Exclude<C, B>>, Chunk<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: Chunk<B>) => [Chunk<B>, Chunk<B>]
-  <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): [Chunk<Exclude<C, B>>, Chunk<B>]
-  <B extends A, A = B>(self: Chunk<B>, predicate: (a: A) => boolean): [Chunk<B>, Chunk<B>]
+  <C extends A, B extends A, A = C>(
+    refinement: (a: A, i: number) => a is B
+  ): (self: Chunk<C>) => [excluded: Chunk<Exclude<C, B>>, satisfying: Chunk<B>]
+  <B extends A, A = B>(
+    predicate: (a: A, i: number) => boolean
+  ): (self: Chunk<B>) => [excluded: Chunk<B>, satisfying: Chunk<B>]
+  <A, B extends A>(
+    self: Chunk<A>,
+    refinement: (a: A, i: number) => a is B
+  ): [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>]
+  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>]
 } = dual(
   2,
-  <B extends A, A = B>(self: Chunk<B>, predicate: (a: A) => boolean): [Chunk<B>, Chunk<B>] =>
+  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>] =>
     pipe(
       RA.partition(toReadonlyArray(self), predicate),
       ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]
@@ -901,9 +908,9 @@ export const partition: {
  * @since 2.0.0
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => [Chunk<B>, Chunk<C>]
-  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [Chunk<B>, Chunk<C>]
-} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [Chunk<B>, Chunk<C>] =>
+  <A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>]
+  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [left: Chunk<B>, right: Chunk<C>]
+} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [left: Chunk<B>, right: Chunk<C>] =>
   pipe(
     RA.partitionMap(toReadonlyArray(self), f),
     ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]
@@ -962,8 +969,8 @@ export const sortWith: {
  * @category elements
  */
 export const splitAt: {
-  (n: number): <A>(self: Chunk<A>) => [Chunk<A>, Chunk<A>]
-  <A>(self: Chunk<A>, n: number): [Chunk<A>, Chunk<A>]
+  (n: number): <A>(self: Chunk<A>) => [beforeIndex: Chunk<A>, fromIndex: Chunk<A>]
+  <A>(self: Chunk<A>, n: number): [beforeIndex: Chunk<A>, fromIndex: Chunk<A>]
 } = dual(2, <A>(self: Chunk<A>, n: number): [Chunk<A>, Chunk<A>] => [take(self, n), drop(self, n)])
 
 /**
@@ -984,9 +991,9 @@ export const split: {
  * @since 2.0.0
  */
 export const splitWhere: {
-  <A>(predicate: Predicate<A>): (self: Chunk<A>) => [Chunk<A>, Chunk<A>]
-  <A>(self: Chunk<A>, predicate: Predicate<A>): [Chunk<A>, Chunk<A>]
-} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): [Chunk<A>, Chunk<A>] => {
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => [beforeMatch: Chunk<B>, fromMatch: Chunk<B>]
+  <A>(self: Chunk<A>, predicate: Predicate<A>): [beforeMatch: Chunk<A>, fromMatch: Chunk<A>]
+} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): [beforeMatch: Chunk<A>, fromMatch: Chunk<A>] => {
   let i = 0
   for (const a of toReadonlyArray(self)) {
     if (predicate(a)) {
@@ -1032,18 +1039,20 @@ export const takeRight: {
  * @category elements
  */
 export const takeWhile: {
-  <A>(predicate: Predicate<A>): (self: Chunk<A>) => Chunk<A>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Chunk<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
+  <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>
   <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>
-} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>) => {
-  const res: Array<A> = []
+} = dual(2, <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A> => {
+  const out: Array<A> = []
   for (const a of toReadonlyArray(self)) {
     if (predicate(a)) {
-      res.push(a)
+      out.push(a)
     } else {
       break
     }
   }
-  return unsafeFromArray(res)
+  return unsafeFromArray(out)
 })
 
 /**
@@ -1236,9 +1245,9 @@ export const containsWith: <A>(
  */
 export const findFirst: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Chunk<B>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Option<B>
   <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>
-  <B extends A, A>(self: Chunk<B>, predicate: Predicate<A>): Option<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>
 } = RA.findFirst
 
 /**
@@ -1260,9 +1269,9 @@ export const findFirstIndex: {
  */
 export const findLast: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Chunk<B>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Option<B>
   <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>
-  <B extends A, A>(self: Chunk<B>, predicate: Predicate<A>): Option<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>
 } = RA.findLast
 
 /**
@@ -1300,12 +1309,11 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <A>(predicate: Predicate<A>): <B extends A>(self: Chunk<B>) => self is NonEmptyChunk<B>
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): self is NonEmptyChunk<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => self is NonEmptyChunk<B>
+  <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A>
 } = dual(
   2,
-  <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): self is NonEmptyChunk<B> =>
-    RA.fromIterable(self).some(predicate)
+  <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A> => RA.fromIterable(self).some(predicate)
 )
 
 /**

package/src/Clock.ts

@@ -31,7 +31,7 @@ export interface Clock {
   /**
    * Unsafely returns the current time in milliseconds.
    */
-  readonly unsafeCurrentTimeMillis: () => number
+  unsafeCurrentTimeMillis(): number
   /**
    * Returns the current time in milliseconds.
    */
@@ -39,7 +39,7 @@ export interface Clock {
   /**
    * Unsafely returns the current time in nanoseconds.
    */
-  readonly unsafeCurrentTimeNanos: () => bigint
+  unsafeCurrentTimeNanos(): bigint
   /**
    * Returns the current time in nanoseconds.
    */
@@ -47,7 +47,7 @@ export interface Clock {
   /**
    * Asynchronously sleeps for the specified duration.
    */
-  readonly sleep: (duration: Duration.Duration) => Effect.Effect<never, never, void>
+  sleep(duration: Duration.Duration): Effect.Effect<never, never, void>
 }
 
 /**
@@ -70,7 +70,7 @@ export interface ClockScheduler {
   /**
    * Unsafely schedules the specified task for the specified duration.
    */
-  readonly unsafeSchedule: (task: Task, duration: Duration.Duration) => CancelToken
+  unsafeSchedule(task: Task, duration: Duration.Duration): CancelToken
 }
 
 /**

package/src/Config.ts

@@ -32,7 +32,7 @@ export type ConfigTypeId = typeof ConfigTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Config<A> extends Config.Variance<A>, Pipeable {}
+export interface Config<out A> extends Config.Variance<A>, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -42,7 +42,7 @@ export declare namespace Config {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<out A> {
     readonly [ConfigTypeId]: {
       readonly _A: (_: never) => A
     }
@@ -52,9 +52,9 @@ export declare namespace Config {
    * @since 2.0.0
    * @category models
    */
-  export interface Primitive<A> extends Config<A> {
+  export interface Primitive<out A> extends Config<A> {
     readonly description: string
-    readonly parse: (text: string) => Either.Either<ConfigError.ConfigError, A>
+    parse(text: string): Either.Either<ConfigError.ConfigError, A>
   }
 
   /**

package/src/ConfigError.ts

@@ -53,18 +53,18 @@ export declare namespace ConfigError {
  * @since 2.0.0
  * @category models
  */
-export interface ConfigErrorReducer<C, Z> {
-  readonly andCase: (context: C, left: Z, right: Z) => Z
-  readonly orCase: (context: C, left: Z, right: Z) => Z
-  readonly invalidDataCase: (context: C, path: Array<string>, message: string) => Z
-  readonly missingDataCase: (context: C, path: Array<string>, message: string) => Z
-  readonly sourceUnavailableCase: (
+export interface ConfigErrorReducer<in C, in out Z> {
+  andCase(context: C, left: Z, right: Z): Z
+  orCase(context: C, left: Z, right: Z): Z
+  invalidDataCase(context: C, path: Array<string>, message: string): Z
+  missingDataCase(context: C, path: Array<string>, message: string): Z
+  sourceUnavailableCase(
     context: C,
     path: Array<string>,
     message: string,
     cause: Cause.Cause<unknown>
-  ) => Z
-  readonly unsupportedCase: (context: C, path: Array<string>, message: string) => Z
+  ): Z
+  unsupportedCase(context: C, path: Array<string>, message: string): Z
 }
 
 /**

package/src/ConfigProvider.ts

@@ -46,7 +46,7 @@ export interface ConfigProvider extends ConfigProvider.Proto, Pipeable {
   /**
    * Loads the specified configuration, or fails with a config error.
    */
-  readonly load: <A>(config: Config.Config<A>) => Effect.Effect<never, ConfigError.ConfigError, A>
+  load<A>(config: Config.Config<A>): Effect.Effect<never, ConfigError.ConfigError, A>
   /**
    * Flattens this config provider into a simplified config provider that knows
    * only how to deal with flat (key/value) properties.
@@ -77,14 +77,14 @@ export declare namespace ConfigProvider {
   export interface Flat {
     readonly [FlatConfigProviderTypeId]: FlatConfigProviderTypeId
     readonly patch: PathPatch.PathPatch
-    readonly load: <A>(
+    load<A>(
       path: ReadonlyArray<string>,
       config: Config.Config.Primitive<A>,
       split?: boolean
-    ) => Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
-    readonly enumerateChildren: (
+    ): Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
+    enumerateChildren(
       path: ReadonlyArray<string>
-    ) => Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>>
+    ): Effect.Effect<never, ConfigError.ConfigError, HashSet.HashSet<string>>
   }
 
   /**

package/src/ConfigProviderPathPatch.ts

@@ -36,7 +36,7 @@ export interface AndThen {
  */
 export interface MapName {
   readonly _tag: "MapName"
-  readonly f: (string: string) => string
+  f(string: string): string
 }
 
 /**

package/src/Console.ts

@@ -25,27 +25,27 @@ export type TypeId = typeof TypeId
  */
 export interface Console {
   readonly [TypeId]: TypeId
-  readonly assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<never, never, void>
+  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<never, never, void>
   readonly clear: Effect<never, never, void>
-  readonly count: (label?: string) => Effect<never, never, void>
-  readonly countReset: (label?: string) => Effect<never, never, void>
-  readonly debug: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly dir: (item: any, options?: any) => Effect<never, never, void>
-  readonly dirxml: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly error: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly group: (options?: {
+  count(label?: string): Effect<never, never, void>
+  countReset(label?: string): Effect<never, never, void>
+  debug(...args: ReadonlyArray<any>): Effect<never, never, void>
+  dir(item: any, options?: any): Effect<never, never, void>
+  dirxml(...args: ReadonlyArray<any>): Effect<never, never, void>
+  error(...args: ReadonlyArray<any>): Effect<never, never, void>
+  group(options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }) => Effect<never, never, void>
+  }): Effect<never, never, void>
   readonly groupEnd: Effect<never, never, void>
-  readonly info: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly log: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<never, never, void>
-  readonly time: (label?: string) => Effect<never, never, void>
-  readonly timeEnd: (label?: string) => Effect<never, never, void>
-  readonly timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly trace: (...args: ReadonlyArray<any>) => Effect<never, never, void>
-  readonly warn: (...args: ReadonlyArray<any>) => Effect<never, never, void>
+  info(...args: ReadonlyArray<any>): Effect<never, never, void>
+  log(...args: ReadonlyArray<any>): Effect<never, never, void>
+  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<never, never, void>
+  time(label?: string): Effect<never, never, void>
+  timeEnd(label?: string): Effect<never, never, void>
+  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<never, never, void>
+  trace(...args: ReadonlyArray<any>): Effect<never, never, void>
+  warn(...args: ReadonlyArray<any>): Effect<never, never, void>
   readonly unsafe: UnsafeConsole
 }
 
@@ -54,27 +54,27 @@ export interface Console {
  * @category model
  */
 export interface UnsafeConsole {
-  readonly assert: (condition: boolean, ...args: ReadonlyArray<any>) => void
-  readonly clear: () => void
-  readonly count: (label?: string) => void
-  readonly countReset: (label?: string) => void
-  readonly debug: (...args: ReadonlyArray<any>) => void
-  readonly dir: (item: any, options?: any) => void
-  readonly dirxml: (...args: ReadonlyArray<any>) => void
-  readonly error: (...args: ReadonlyArray<any>) => void
-  readonly group: (options?: {
+  assert(condition: boolean, ...args: ReadonlyArray<any>): void
+  clear(): void
+  count(label?: string): void
+  countReset(label?: string): void
+  debug(...args: ReadonlyArray<any>): void
+  dir(item: any, options?: any): void
+  dirxml(...args: ReadonlyArray<any>): void
+  error(...args: ReadonlyArray<any>): void
+  group(options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }) => void
-  readonly groupEnd: () => void
-  readonly info: (...args: ReadonlyArray<any>) => void
-  readonly log: (...args: ReadonlyArray<any>) => void
-  readonly table: (tabularData: any, properties?: ReadonlyArray<string>) => void
-  readonly time: (label?: string) => void
-  readonly timeEnd: (label?: string) => void
-  readonly timeLog: (label?: string, ...args: ReadonlyArray<any>) => void
-  readonly trace: (...args: ReadonlyArray<any>) => void
-  readonly warn: (...args: ReadonlyArray<any>) => void
+  }): void
+  groupEnd(): void
+  info(...args: ReadonlyArray<any>): void
+  log(...args: ReadonlyArray<any>): void
+  table(tabularData: any, properties?: ReadonlyArray<string>): void
+  time(label?: string): void
+  timeEnd(label?: string): void
+  timeLog(label?: string, ...args: ReadonlyArray<any>): void
+  trace(...args: ReadonlyArray<any>): void
+  warn(...args: ReadonlyArray<any>): void
 }
 
 /**

package/src/Context.ts

@@ -26,15 +26,15 @@ export type TagTypeId = typeof TagTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Tag<Identifier, Service> extends Pipeable, Inspectable {
+export interface Tag<in out Identifier, in out Service> extends Pipeable, Inspectable {
   readonly _tag: "Tag"
   readonly _op: "Tag"
   readonly [TagTypeId]: {
     readonly _S: (_: Service) => Service
     readonly _I: (_: Identifier) => Identifier
   }
-  readonly of: (self: Service) => Service
-  readonly context: (self: Service) => Context<Identifier>
+  of(self: Service): Service
+  context(self: Service): Context<Identifier>
   readonly stack?: string | undefined
   readonly identifier?: unknown
   [Unify.typeSymbol]?: unknown
@@ -111,7 +111,7 @@ export type ValidTagsById<R> = R extends infer S ? Tag<S, any> : never
  * @since 2.0.0
  * @category models
  */
-export interface Context<Services> extends Equal, Pipeable, Inspectable {
+export interface Context<in Services> extends Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
     readonly _S: (_: Services) => unknown
   }

package/src/Data.ts

@@ -1,13 +1,11 @@
 /**
  * @since 2.0.0
  */
-import type * as Channel from "./Channel.js"
-import * as Effect from "./Effect.js"
-import * as Effectable from "./Effectable.js"
+import type * as Cause from "./Cause.js"
 import type * as Equal from "./Equal.js"
+import * as core from "./internal/core.js"
 import * as internal from "./internal/data.js"
-import { type Pipeable } from "./Pipeable.js"
-import type * as Sink from "./Sink.js"
+import { StructuralPrototype } from "./internal/effectable.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -69,7 +67,7 @@ export const struct: <A extends Record<string, any>>(a: A) => Data<{ readonly [P
  * @since 2.0.0
  */
 export const unsafeStruct = <A extends Record<string, any>>(as: A): Data<{ readonly [P in keyof A]: A[P] }> =>
-  Object.setPrototypeOf(as, internal.StructProto)
+  Object.setPrototypeOf(as, StructuralPrototype)
 
 /**
  * @example
@@ -126,7 +124,7 @@ export const unsafeArray = <As extends ReadonlyArray<any>>(as: As): Data<Readonl
   Object.setPrototypeOf(as, internal.ArrayProto)
 
 const _case = <A extends Case>(): Case.Constructor<A> => (args) =>
-  (args === undefined ? Object.create(internal.StructProto) : struct(args)) as any
+  (args === undefined ? Object.create(StructuralPrototype) : struct(args)) as any
 
 export {
   /**
@@ -183,7 +181,7 @@ export const tagged = <A extends Case & { readonly _tag: string }>(
   tag: A["_tag"]
 ): Case.Constructor<A, "_tag"> =>
 (args) => {
-  const value = args === undefined ? Object.create(internal.StructProto) : struct(args)
+  const value = args === undefined ? Object.create(StructuralPrototype) : struct(args)
   value._tag = tag
   return value
 }
@@ -442,35 +440,6 @@ export const taggedEnum: {
     }
   }) as any
 
-/**
- * @since 2.0.0
- * @category models
- */
-export interface YieldableError extends Case, Pipeable, Readonly<Error> {
-  readonly [Effectable.EffectTypeId]: Effect.Effect.VarianceStruct<never, this, never>
-  readonly [Effectable.StreamTypeId]: Effect.Effect.VarianceStruct<never, this, never>
-  readonly [Effectable.SinkTypeId]: Sink.Sink.VarianceStruct<never, this, unknown, never, never>
-  readonly [Effectable.ChannelTypeId]: Channel.Channel.VarianceStruct<
-    never,
-    unknown,
-    unknown,
-    unknown,
-    this,
-    never,
-    never
-  >
-}
-
-const YieldableErrorProto = {
-  ...Effectable.StructuralCommitPrototype,
-  commit() {
-    return Effect.fail(this)
-  },
-  toString(this: globalThis.Error) {
-    return `${this.name}: ${this.message}`
-  }
-}
-
 /**
  * Provides a constructor for a Case Class.
  *
@@ -480,15 +449,15 @@ const YieldableErrorProto = {
 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] }
-) => YieldableError & Readonly<A> = (function() {
-  class Base extends globalThis.Error {
+) => Cause.YieldableError & Readonly<A> = (function() {
+  return class Base extends core.YieldableError {
     constructor(args: any) {
       super()
-      Object.assign(this, args)
+      if (args) {
+        Object.assign(this, args)
+      }
     }
-  }
-  Object.assign(Base.prototype, YieldableErrorProto)
-  return Base as any
+  } as any
 })()
 
 /**
@@ -498,7 +467,7 @@ export const Error: 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] }
-) => YieldableError & { readonly _tag: Tag } & Readonly<A> => {
+) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A> => {
   class Base extends Error<{}> {
     readonly _tag = tag
   }

package/src/Deferred.ts

@@ -36,7 +36,7 @@ export type DeferredTypeId = typeof DeferredTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Deferred<E, A> extends Deferred.Variance<E, A>, Pipeable {
+export interface Deferred<in out E, in out A> extends Deferred.Variance<E, A>, Pipeable {
   /** @internal */
   readonly state: MutableRef.MutableRef<internal.State<E, A>>
   /** @internal */
@@ -51,10 +51,10 @@ export declare namespace Deferred {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<in out E, in out A> {
     readonly [DeferredTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: (_: E) => E
+      readonly _A: (_: A) => A
     }
   }
 }

package/src/Differ.ts

@@ -46,15 +46,15 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface Differ<Value, Patch> {
+export interface Differ<in out Value, in out Patch> {
   readonly [TypeId]: {
     readonly _V: (_: Value) => Value
     readonly _P: (_: Patch) => Patch
   }
   readonly empty: Patch
-  readonly diff: (oldValue: Value, newValue: Value) => Patch
-  readonly combine: (first: Patch, second: Patch) => Patch
-  readonly patch: (patch: Patch, oldValue: Value) => Value
+  diff(oldValue: Value, newValue: Value): Patch
+  combine(first: Patch, second: Patch): Patch
+  patch(patch: Patch, oldValue: Value): Value
 }
 
 const ChunkPatchTypeId: unique symbol = ChunkPatch.ChunkPatchTypeId as Differ.Chunk.TypeId
@@ -84,7 +84,7 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Input, Output> extends Equal {
+    export interface Patch<in Input, out Output> extends Equal {
       readonly [ContextPatchTypeId]: {
         readonly _Input: (_: Input) => void
         readonly _Output: (_: never) => Output
@@ -107,7 +107,7 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Value, Patch> extends Equal {
+    export interface Patch<in out Value, in out Patch> extends Equal {
       readonly [ChunkPatchTypeId]: {
         readonly _Value: (_: Value) => Value
         readonly _Patch: (_: Patch) => Patch
@@ -130,7 +130,7 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Key, Value, Patch> extends Equal {
+    export interface Patch<in out Key, in out Value, in out Patch> extends Equal {
       readonly [HashMapPatchTypeId]: {
         readonly _Key: (_: Key) => Key
         readonly _Value: (_: Value) => Value
@@ -154,7 +154,7 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Value> extends Equal {
+    export interface Patch<in out Value> extends Equal {
       readonly [HashSetPatchTypeId]: {
         readonly _Value: (_: Value) => Value
       }
@@ -176,7 +176,7 @@ export declare namespace Differ {
      * @since 2.0.0
      * @category models
      */
-    export interface Patch<Value, Value2, Patch, Patch2> extends Equal {
+    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