effect 2.0.0-next.55 → 2.0.0-next.57

package/src/internal/blockedRequests.ts

@@ -11,7 +11,7 @@ import type * as RequestBlock from "../RequestBlock.js"
 import type * as RequestResolver from "../RequestResolver.js"
 
 /** @internal */
-export const empty: RequestBlock.RequestBlock<never> = {
+export const empty: RequestBlock.RequestBlock = {
   _tag: "Empty"
 }
 
@@ -21,10 +21,10 @@ export const empty: RequestBlock.RequestBlock<never> = {
  *
  * @internal
  */
-export const par = <R, R2>(
-  self: RequestBlock.RequestBlock<R>,
-  that: RequestBlock.RequestBlock<R2>
-): RequestBlock.RequestBlock<R | R2> => ({
+export const par = (
+  self: RequestBlock.RequestBlock,
+  that: RequestBlock.RequestBlock
+): RequestBlock.RequestBlock => ({
   _tag: "Par",
   left: self,
   right: that
@@ -36,10 +36,10 @@ export const par = <R, R2>(
  *
  * @internal
  */
-export const seq = <R, R2>(
-  self: RequestBlock.RequestBlock<R>,
-  that: RequestBlock.RequestBlock<R2>
-): RequestBlock.RequestBlock<R | R2> => ({
+export const seq = (
+  self: RequestBlock.RequestBlock,
+  that: RequestBlock.RequestBlock
+): RequestBlock.RequestBlock => ({
   _tag: "Seq",
   left: self,
   right: that
@@ -51,19 +51,19 @@ export const seq = <R, R2>(
  *
  * @internal
  */
-export const single = <R, A>(
-  dataSource: RequestResolver.RequestResolver<A, R>,
+export const single = <A>(
+  dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
-): RequestBlock.RequestBlock<R> => ({
+): RequestBlock.RequestBlock => ({
   _tag: "Single",
   dataSource: dataSource as any,
   blockedRequest
 })
 
 /** @internal */
-export const MapRequestResolversReducer = <R, A, R2>(
-  f: (dataSource: RequestResolver.RequestResolver<A, R>) => RequestResolver.RequestResolver<A, R2>
-): RequestBlock.RequestBlock.Reducer<R, RequestBlock.RequestBlock<R | R2>> => ({
+export const MapRequestResolversReducer = <A>(
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+): RequestBlock.RequestBlock.Reducer<RequestBlock.RequestBlock> => ({
   emptyCase: () => empty,
   parCase: (left, right) => par(left, right),
   seqCase: (left, right) => seq(left, right),
@@ -87,10 +87,10 @@ interface SeqCase {
  *
  * @internal
  */
-export const mapRequestResolvers = <R, A, R2>(
-  self: RequestBlock.RequestBlock<R>,
-  f: (dataSource: RequestResolver.RequestResolver<A, R>) => RequestResolver.RequestResolver<A, R2>
-): RequestBlock.RequestBlock<R | R2> => reduce(self, MapRequestResolversReducer(f))
+export const mapRequestResolvers = <A>(
+  self: RequestBlock.RequestBlock,
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+): RequestBlock.RequestBlock => reduce(self, MapRequestResolversReducer(f))
 
 /**
  * Folds over the cases of this collection of blocked requests with the
@@ -98,14 +98,14 @@ export const mapRequestResolvers = <R, A, R2>(
  *
  * @internal
  */
-export const reduce = <R, Z>(
-  self: RequestBlock.RequestBlock<R>,
-  reducer: RequestBlock.RequestBlock.Reducer<R, Z>
+export const reduce = <Z>(
+  self: RequestBlock.RequestBlock,
+  reducer: RequestBlock.RequestBlock.Reducer<Z>
 ): Z => {
-  let input: List.List<RequestBlock.RequestBlock<R>> = List.of(self)
+  let input: List.List<RequestBlock.RequestBlock> = List.of(self)
   let output = List.empty<Either.Either<BlockedRequestsCase, Z>>()
   while (List.isCons(input)) {
-    const current: RequestBlock.RequestBlock<R> = input.head
+    const current: RequestBlock.RequestBlock = input.head
     switch (current._tag) {
       case "Empty": {
         output = List.cons(Either.right(reducer.emptyCase()), output)
@@ -164,16 +164,16 @@ export const reduce = <R, Z>(
  *
  * @internal
  */
-export const flatten = <R>(
-  self: RequestBlock.RequestBlock<R>
-): List.List<SequentialCollection<R>> => {
+export const flatten = (
+  self: RequestBlock.RequestBlock
+): List.List<SequentialCollection> => {
   let current = List.of(self)
-  let updated = List.empty<SequentialCollection<R>>()
+  let updated = List.empty<SequentialCollection>()
   // eslint-disable-next-line no-constant-condition
   while (1) {
     const [parallel, sequential] = List.reduce(
       current,
-      [parallelCollectionEmpty<R>(), List.empty<RequestBlock.RequestBlock<R>>()] as const,
+      [parallelCollectionEmpty(), List.empty<RequestBlock.RequestBlock>()] as const,
       ([parallel, sequential], blockedRequest) => {
         const [par, seq] = step(blockedRequest)
         return [
@@ -199,13 +199,13 @@ export const flatten = <R>(
  * of blocked requests that must be performed sequentially after those
  * requests.
  */
-const step = <R>(
-  requests: RequestBlock.RequestBlock<R>
-): [ParallelCollection<R>, List.List<RequestBlock.RequestBlock<R>>] => {
-  let current: RequestBlock.RequestBlock<R> = requests
-  let parallel = parallelCollectionEmpty<R>()
-  let stack = List.empty<RequestBlock.RequestBlock<R>>()
-  let sequential = List.empty<RequestBlock.RequestBlock<R>>()
+const step = (
+  requests: RequestBlock.RequestBlock
+): [ParallelCollection, List.List<RequestBlock.RequestBlock>] => {
+  let current: RequestBlock.RequestBlock = requests
+  let parallel = parallelCollectionEmpty()
+  let stack = List.empty<RequestBlock.RequestBlock>()
+  let sequential = List.empty<RequestBlock.RequestBlock>()
   // eslint-disable-next-line no-constant-condition
   while (1) {
     switch (current._tag) {
@@ -275,10 +275,10 @@ const step = <R>(
  * are both from the same single data source then the requests can be
  * pipelined while preserving ordering guarantees.
  */
-const merge = <R>(
-  sequential: List.List<SequentialCollection<R>>,
-  parallel: ParallelCollection<R>
-): List.List<SequentialCollection<R>> => {
+const merge = (
+  sequential: List.List<SequentialCollection>,
+  parallel: ParallelCollection
+): List.List<SequentialCollection> => {
   if (List.isNil(sequential)) {
     return List.of(parallelCollectionToSequentialCollection(parallel))
   }
@@ -326,8 +326,8 @@ class EntryImpl<A extends Request.Request<any, any>> implements Request.Entry<A>
   ) {}
 }
 
-/** @internal */
 const blockedRequestVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
@@ -351,10 +351,11 @@ export const RequestBlockParallelTypeId = Symbol.for(
 )
 
 const parallelVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
-class ParallelImpl<R> implements ParallelCollection<R> {
+class ParallelImpl implements ParallelCollection {
   readonly [RequestBlockParallelTypeId] = parallelVariance
   constructor(
     readonly map: HashMap.HashMap<
@@ -365,19 +366,19 @@ class ParallelImpl<R> implements ParallelCollection<R> {
 }
 
 /** @internal */
-export const parallelCollectionEmpty = <R>(): ParallelCollection<R> => new ParallelImpl(HashMap.empty())
+export const parallelCollectionEmpty = (): ParallelCollection => new ParallelImpl(HashMap.empty())
 
 /** @internal */
-export const parallelCollectionMake = <R, A>(
-  dataSource: RequestResolver.RequestResolver<A, R>,
+export const parallelCollectionMake = <A>(
+  dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
-): ParallelCollection<R> => new ParallelImpl(HashMap.make([dataSource, Array.of(blockedRequest)]) as any)
+): ParallelCollection => new ParallelImpl(HashMap.make([dataSource, Array.of(blockedRequest)]) as any)
 
 /** @internal */
-export const parallelCollectionCombine = <R, R2>(
-  self: ParallelCollection<R>,
-  that: ParallelCollection<R2>
-): ParallelCollection<R | R2> =>
+export const parallelCollectionCombine = (
+  self: ParallelCollection,
+  that: ParallelCollection
+): ParallelCollection =>
   new ParallelImpl(HashMap.reduce(self.map, that.map, (map, value, key) =>
     HashMap.set(
       map,
@@ -389,17 +390,17 @@ export const parallelCollectionCombine = <R, R2>(
     )))
 
 /** @internal */
-export const parallelCollectionIsEmpty = <R>(self: ParallelCollection<R>): boolean => HashMap.isEmpty(self.map)
+export const parallelCollectionIsEmpty = (self: ParallelCollection): boolean => HashMap.isEmpty(self.map)
 
 /** @internal */
-export const parallelCollectionKeys = <R>(
-  self: ParallelCollection<R>
-): Array<RequestResolver.RequestResolver<unknown, R>> => Array.from(HashMap.keys(self.map)) as any
+export const parallelCollectionKeys = (
+  self: ParallelCollection
+): Array<RequestResolver.RequestResolver<unknown>> => Array.from(HashMap.keys(self.map)) as any
 
 /** @internal */
-export const parallelCollectionToSequentialCollection = <R>(
-  self: ParallelCollection<R>
-): SequentialCollection<R> => sequentialCollectionMake(HashMap.map(self.map, (x) => Array.of(x)) as any)
+export const parallelCollectionToSequentialCollection = (
+  self: ParallelCollection
+): SequentialCollection => sequentialCollectionMake(HashMap.map(self.map, (x) => Array.of(x)) as any)
 
 // TODO
 // /** @internal */
@@ -412,12 +413,12 @@ export const SequentialCollectionTypeId = Symbol.for(
   "effect/RequestBlock/RequestBlockSequential"
 )
 
-/** @internal */
 const sequentialVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
-class SequentialImpl<R> implements SequentialCollection<R> {
+class SequentialImpl implements SequentialCollection {
   readonly [SequentialCollectionTypeId] = sequentialVariance
   constructor(
     readonly map: HashMap.HashMap<
@@ -433,13 +434,13 @@ export const sequentialCollectionMake = <R, A>(
     RequestResolver.RequestResolver<A, R>,
     Array<Array<Request.Entry<A>>>
   >
-): SequentialCollection<R> => new SequentialImpl(map as any)
+): SequentialCollection => new SequentialImpl(map as any)
 
 /** @internal */
-export const sequentialCollectionCombine = <R, R2>(
-  self: SequentialCollection<R>,
-  that: SequentialCollection<R2>
-): SequentialCollection<R | R2> =>
+export const sequentialCollectionCombine = (
+  self: SequentialCollection,
+  that: SequentialCollection
+): SequentialCollection =>
   new SequentialImpl(HashMap.reduce(that.map, self.map, (map, value, key) =>
     HashMap.set(
       map,
@@ -451,24 +452,24 @@ export const sequentialCollectionCombine = <R, R2>(
     )))
 
 /** @internal */
-export const sequentialCollectionIsEmpty = <R>(self: SequentialCollection<R>): boolean => HashMap.isEmpty(self.map)
+export const sequentialCollectionIsEmpty = (self: SequentialCollection): boolean => HashMap.isEmpty(self.map)
 
 /** @internal */
-export const sequentialCollectionKeys = <R>(
-  self: SequentialCollection<R>
-): Array<RequestResolver.RequestResolver<unknown, R>> => Array.from(HashMap.keys(self.map)) as any
+export const sequentialCollectionKeys = (
+  self: SequentialCollection
+): Array<RequestResolver.RequestResolver<unknown>> => Array.from(HashMap.keys(self.map)) as any
 
 /** @internal */
-export const sequentialCollectionToChunk = <R>(
-  self: SequentialCollection<R>
-): Array<[RequestResolver.RequestResolver<unknown, R>, Array<Array<Request.Entry<unknown>>>]> =>
+export const sequentialCollectionToChunk = (
+  self: SequentialCollection
+): Array<[RequestResolver.RequestResolver<unknown>, Array<Array<Request.Entry<unknown>>>]> =>
   Array.from(self.map) as any
 
 /** @internal */
 export type RequestBlockParallelTypeId = typeof RequestBlockParallelTypeId
 
 /** @internal */
-export interface ParallelCollection<R> extends ParallelCollection.Variance<R> {
+export interface ParallelCollection extends ParallelCollection.Variance {
   readonly map: HashMap.HashMap<
     RequestResolver.RequestResolver<unknown, unknown>,
     Array<Request.Entry<unknown>>
@@ -478,10 +479,8 @@ export interface ParallelCollection<R> extends ParallelCollection.Variance<R> {
 /** @internal */
 export declare namespace ParallelCollection {
   /** @internal */
-  export interface Variance<R> {
-    readonly [RequestBlockParallelTypeId]: {
-      readonly _R: (_: never) => R
-    }
+  export interface Variance {
+    readonly [RequestBlockParallelTypeId]: {}
   }
 }
 
@@ -489,7 +488,7 @@ export declare namespace ParallelCollection {
 export type SequentialCollectionTypeId = typeof SequentialCollectionTypeId
 
 /** @internal */
-export interface SequentialCollection<R> extends SequentialCollection.Variance<R> {
+export interface SequentialCollection extends SequentialCollection.Variance {
   readonly map: HashMap.HashMap<
     RequestResolver.RequestResolver<unknown, unknown>,
     Array<Array<Request.Entry<unknown>>>
@@ -499,9 +498,7 @@ export interface SequentialCollection<R> extends SequentialCollection.Variance<R
 /** @internal */
 export declare namespace SequentialCollection {
   /** @internal */
-  export interface Variance<R> {
-    readonly [SequentialCollectionTypeId]: {
-      readonly _R: (_: never) => R
-    }
+  export interface Variance {
+    readonly [SequentialCollectionTypeId]: {}
   }
 }

package/src/internal/cache.ts

@@ -35,7 +35,7 @@ export type MapValue<Key, Error, Value> =
   | Refreshing<Key, Error, Value>
 
 /** @internal */
-export interface Complete<Key, Error, Value> {
+export interface Complete<out Key, out Error, out Value> {
   readonly _tag: "Complete"
   readonly key: MapKey<Key>
   readonly exit: Exit.Exit<Error, Value>
@@ -44,14 +44,14 @@ export interface Complete<Key, Error, Value> {
 }
 
 /** @internal */
-export interface Pending<Key, Error, Value> {
+export interface Pending<out Key, in out Error, in out Value> {
   readonly _tag: "Pending"
   readonly key: MapKey<Key>
   readonly deferred: Deferred.Deferred<Error, Value>
 }
 
 /** @internal */
-export interface Refreshing<Key, Error, Value> {
+export interface Refreshing<out Key, in out Error, in out Value> {
   readonly _tag: "Refreshing"
   readonly deferred: Deferred.Deferred<Error, Value>
   readonly complete: Complete<Key, Error, Value>
@@ -107,14 +107,14 @@ export type MapKeyTypeId = typeof MapKeyTypeId
  *
  * @internal
  */
-export interface MapKey<K> extends Equal.Equal {
+export interface MapKey<out K> extends Equal.Equal {
   readonly [MapKeyTypeId]: MapKeyTypeId
   readonly current: K
   previous: MapKey<K> | undefined // mutable by design
   next: MapKey<K> | undefined // mutable by design
 }
 
-class MapKeyImpl<K> implements MapKey<K> {
+class MapKeyImpl<out K> implements MapKey<K> {
   readonly [MapKeyTypeId]: MapKeyTypeId = MapKeyTypeId
   previous: MapKey<K> | undefined = undefined
   next: MapKey<K> | undefined = undefined
@@ -150,20 +150,20 @@ export const isMapKey = (u: unknown): u is MapKey<unknown> => hasProperty(u, Map
  *
  * @internal
  */
-export interface KeySet<K> {
+export interface KeySet<in out K> {
   head: MapKey<K> | undefined // mutable by design
   tail: MapKey<K> | undefined // mutable by design
   /**
    * Adds the specified key to the set.
    */
-  readonly add: (key: MapKey<K>) => void
+  add(key: MapKey<K>): void
   /**
    * Removes the lowest priority key from the set.
    */
-  readonly remove: () => MapKey<K> | undefined
+  remove(): MapKey<K> | undefined
 }
 
-class KeySetImpl<K> implements KeySet<K> {
+class KeySetImpl<in out K> implements KeySet<K> {
   head: MapKey<K> | undefined = undefined
   tail: MapKey<K> | undefined = undefined
   add(key: MapKey<K>): void {
@@ -215,7 +215,7 @@ export const makeKeySet = <K>(): KeySet<K> => new KeySetImpl<K>()
  *
  * @internal
  */
-export interface CacheState<Key, Error, Value> {
+export interface CacheState<in out Key, in out Error, in out Value> {
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
   keys: KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<MapKey<Key>> // mutable by design
@@ -269,8 +269,11 @@ export const CacheTypeId: Cache.CacheTypeId = Symbol.for(
 ) as Cache.CacheTypeId
 
 const cacheVariance = {
-  _Key: (_: unknown) => _,
+  /* c8 ignore next */
+  _Key: (_: any) => _,
+  /* c8 ignore next */
   _Error: (_: never) => _,
+  /* c8 ignore next */
   _Value: (_: never) => _
 }
 
@@ -288,7 +291,7 @@ export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({
   loadedMillis
 })
 
-class CacheImpl<Key, Error, Value> implements Cache.Cache<Key, Error, Value> {
+class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<Key, Error, Value> {
   readonly [CacheTypeId] = cacheVariance
   readonly cacheState: CacheState<Key, Error, Value>
   constructor(

package/src/internal/cause.ts

@@ -2,14 +2,14 @@ import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
-import * as FiberId from "../FiberId.js"
+import type * as FiberId from "../FiberId.js"
 import { constFalse, constTrue, dual, identity, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
 import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isFunction, isString, type Predicate } from "../Predicate.js"
+import { hasProperty, isFunction, type Predicate } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as OpCodes from "./opCodes/cause.js"
 
@@ -27,8 +27,8 @@ export const CauseTypeId: Cause.CauseTypeId = Symbol.for(
   CauseSymbolKey
 ) as Cause.CauseTypeId
 
-/** @internal */
 const variance = {
+  /* c8 ignore next */
   _E: (_: never) => _
 }
 
@@ -485,6 +485,18 @@ export const flatMap = dual<
 /** @internal */
 export const flatten = <E>(self: Cause.Cause<Cause.Cause<E>>): Cause.Cause<E> => flatMap(self, identity)
 
+/** @internal */
+export const andThen: {
+  <E, E2>(f: (e: E) => Cause.Cause<E2>): (self: Cause.Cause<E>) => Cause.Cause<E2>
+  <E2>(f: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E2>
+  <E, E2>(self: Cause.Cause<E>, f: (e: E) => Cause.Cause<E2>): Cause.Cause<E2>
+  <E, E2>(self: Cause.Cause<E>, f: Cause.Cause<E2>): Cause.Cause<E2>
+} = dual(
+  2,
+  <E, E2>(self: Cause.Cause<E>, f: ((e: E) => Cause.Cause<E2>) | Cause.Cause<E2>): Cause.Cause<E2> =>
+    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
+)
+
 // -----------------------------------------------------------------------------
 // Equality
 // -----------------------------------------------------------------------------
@@ -593,43 +605,6 @@ const flattenCauseLoop = (
   throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
 }
 
-// -----------------------------------------------------------------------------
-// Squashing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export const squash = <E>(self: Cause.Cause<E>): unknown => {
-  return squashWith(identity)(self)
-}
-
-/** @internal */
-export const squashWith = dual<
-  <E>(f: (error: E) => unknown) => (self: Cause.Cause<E>) => unknown,
-  <E>(self: Cause.Cause<E>, f: (error: E) => unknown) => unknown
->(2, (self, f) => {
-  const option = pipe(self, failureOption, Option.map(f))
-  switch (option._tag) {
-    case "None": {
-      return pipe(
-        defects(self),
-        Chunk.head,
-        Option.match({
-          onNone: () => {
-            const interrupts = Array.from(interruptors(self)).flatMap((fiberId) =>
-              Array.from(FiberId.ids(fiberId)).map((id) => `#${id}`)
-            )
-            return InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0)
-          },
-          onSome: identity
-        })
-      )
-    }
-    case "Some": {
-      return option.value
-    }
-  }
-})
-
 // -----------------------------------------------------------------------------
 // Finding
 // -----------------------------------------------------------------------------
@@ -978,105 +953,6 @@ export const reduceWithContext = dual<
   return accumulator.pop()!
 })
 
-// -----------------------------------------------------------------------------
-// Errors
-// -----------------------------------------------------------------------------
-
-const makeException = <T extends { _tag: string; message?: string }>(
-  proto: Omit<T, "message" | "_tag">,
-  tag: T["_tag"]
-) => {
-  const _tag = {
-    value: tag,
-    enumerable: true
-  }
-  const protoWithToString = {
-    ...proto,
-    toString(this: { _tag: string; message?: string }): string {
-      return `${this._tag}: ${this.message}`
-    }
-  }
-  return (message?: string): T => {
-    const properties: PropertyDescriptorMap = { _tag }
-    if (isString(message)) {
-      properties["message"] = {
-        value: message,
-        enumerable: true
-      }
-    }
-    return Object.create(protoWithToString, properties)
-  }
-}
-
-/** @internal */
-export const RuntimeExceptionTypeId: Cause.RuntimeExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/RuntimeException"
-) as Cause.RuntimeExceptionTypeId
-
-/** @internal */
-export const RuntimeException = makeException<Cause.RuntimeException>({
-  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
-}, "RuntimeException")
-
-/** @internal */
-export const isRuntimeException = (u: unknown): u is Cause.RuntimeException => hasProperty(u, RuntimeExceptionTypeId)
-
-/** @internal */
-export const InterruptedExceptionTypeId: Cause.InterruptedExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/InterruptedException"
-) as Cause.InterruptedExceptionTypeId
-
-/** @internal */
-export const InterruptedException = makeException<Cause.InterruptedException>({
-  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
-}, "InterruptedException")
-
-/** @internal */
-export const isInterruptedException = (u: unknown): u is Cause.InterruptedException =>
-  hasProperty(u, InterruptedExceptionTypeId)
-
-/** @internal */
-export const IllegalArgumentExceptionTypeId: Cause.IllegalArgumentExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/IllegalArgument"
-) as Cause.IllegalArgumentExceptionTypeId
-
-/** @internal */
-export const IllegalArgumentException = makeException<Cause.IllegalArgumentException>({
-  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
-}, "IllegalArgumentException")
-
-/** @internal */
-export const isIllegalArgumentException = (u: unknown): u is Cause.IllegalArgumentException =>
-  hasProperty(u, IllegalArgumentExceptionTypeId)
-
-/** @internal */
-export const NoSuchElementExceptionTypeId: Cause.NoSuchElementExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/NoSuchElement"
-) as Cause.NoSuchElementExceptionTypeId
-
-/** @internal */
-export const NoSuchElementException = makeException<Cause.NoSuchElementException>({
-  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
-}, "NoSuchElementException")
-
-/** @internal */
-export const isNoSuchElementException = (u: unknown): u is Cause.NoSuchElementException =>
-  hasProperty(u, NoSuchElementExceptionTypeId)
-
-/** @internal */
-export const InvalidPubSubCapacityExceptionTypeId: Cause.InvalidPubSubCapacityExceptionTypeId = Symbol.for(
-  "effect/Cause/errors/InvalidPubSubCapacityException"
-) as Cause.InvalidPubSubCapacityExceptionTypeId
-
-/** @internal */
-export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubCapacityException>({
-  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
-}, "InvalidPubSubCapacityException")
-
-/** @internal */
-export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
-  hasProperty(u, InvalidPubSubCapacityExceptionTypeId)
-
 // -----------------------------------------------------------------------------
 // Pretty Printing
 // -----------------------------------------------------------------------------

package/src/internal/channel/channelExecutor.ts

@@ -60,7 +60,7 @@ export type ErasedContinuation<R> = Continuation.Continuation<
 export type ErasedFinalizer<R> = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R, never, unknown>
 
 /** @internal */
-export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
   private _activeSubexecutor: Subexecutor.Subexecutor<Env> | undefined = undefined
 
   private _cancelled: Exit.Exit<OutErr, OutDone> | undefined = undefined

package/src/internal/channel/channelState.ts

@@ -1,6 +1,7 @@
 import * as Effect from "../../Effect.js"
 import type * as Exit from "../../Exit.js"
 import { hasProperty } from "../../Predicate.js"
+import type * as Types from "../../Types.js"
 import * as OpCodes from "../opCodes/channelState.js"
 import type { ErasedExecutor } from "./channelExecutor.js"
 
@@ -11,21 +12,22 @@ export const ChannelStateTypeId = Symbol.for("effect/ChannelState")
 export type ChannelStateTypeId = typeof ChannelStateTypeId
 
 /** @internal */
-export interface ChannelState<R, E> extends ChannelState.Variance<R, E> {}
+export interface ChannelState<out R, out E> extends ChannelState.Variance<R, E> {}
 
 /** @internal */
 export declare namespace ChannelState {
-  export interface Variance<R, E> {
+  export interface Variance<out R, out E> {
     readonly [ChannelStateTypeId]: {
-      readonly _R: (_: never) => R
-      readonly _E: (_: never) => E
+      readonly _R: Types.Covariant<R>
+      readonly _E: Types.Covariant<E>
     }
   }
 }
 
-/** @internal */
 const channelStateVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _
 }
 
@@ -63,9 +65,9 @@ export interface FromEffect extends
 export interface Read extends
   Op<OpCodes.OP_READ, {
     readonly upstream: ErasedExecutor<unknown>
-    readonly onEffect: (effect: Effect.Effect<unknown, never, void>) => Effect.Effect<unknown, never, void>
-    readonly onEmit: (value: unknown) => Effect.Effect<unknown, never, void>
-    readonly onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, void>
+    onEffect(effect: Effect.Effect<unknown, never, void>): Effect.Effect<unknown, never, void>
+    onEmit(value: unknown): Effect.Effect<unknown, never, void>
+    onDone(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, void>
   }>
 {}