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

package/src/internal/effect/circular.ts

@@ -300,7 +300,7 @@ export const fromFiberEffect = <R, E, A>(fiber: Effect.Effect<R, E, Fiber.Fiber<
 
 const memoKeySymbol = Symbol.for("effect/Effect/memoizeFunction.key")
 
-class Key<A> implements Equal.Equal {
+class Key<in out A> implements Equal.Equal {
   [memoKeySymbol] = memoKeySymbol
   constructor(readonly a: A, readonly eq?: Equivalence<A>) {}
   [Equal.symbol](that: Equal.Equal) {
@@ -534,11 +534,11 @@ export const SynchronizedTypeId: Synchronized.SynchronizedRefTypeId = Symbol.for
 
 /** @internal */
 export const synchronizedVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /** @internal */
-class SynchronizedImpl<A> implements Synchronized.SynchronizedRef<A> {
+class SynchronizedImpl<in out A> implements Synchronized.SynchronizedRef<A> {
   readonly [SynchronizedTypeId] = synchronizedVariance
   readonly [internalRef.RefTypeId] = internalRef.refVariance
   constructor(

package/src/internal/effectable.ts

@@ -6,7 +6,6 @@ import * as Hash from "../Hash.js"
 import { pipeArguments } from "../Pipeable.js"
 import type * as Sink from "../Sink.js"
 import type * as Stream from "../Stream.js"
-import * as Data from "./data.js"
 import * as OpCodes from "./opCodes/effect.js"
 import { moduleVersion } from "./version.js"
 
@@ -67,6 +66,26 @@ export const EffectPrototype: Effect.Effect<never, never, never> = {
   }
 }
 
+/** @internal */
+export const StructuralPrototype: Equal.Equal = {
+  [Hash.symbol](this: Equal.Equal) {
+    return Hash.structure(this)
+  },
+  [Equal.symbol](this: Equal.Equal, that: Equal.Equal) {
+    const selfKeys = Object.keys(this)
+    const thatKeys = Object.keys(that as object)
+    if (selfKeys.length !== thatKeys.length) {
+      return false
+    }
+    for (const key of selfKeys) {
+      if (!(key in (that as object) && Equal.equals((this as any)[key], (that as any)[key]))) {
+        return false
+      }
+    }
+    return true
+  }
+}
+
 /** @internal */
 export const CommitPrototype: Effect.Effect<never, never, never> = {
   ...EffectPrototype,
@@ -74,10 +93,10 @@ export const CommitPrototype: Effect.Effect<never, never, never> = {
 } as any
 
 /** @internal */
-export const StructuralCommitPrototype = {
+export const StructuralCommitPrototype: Effect.Effect<never, never, never> = {
   ...CommitPrototype,
-  ...Data.Structural.prototype
-}
+  ...StructuralPrototype
+} as any
 
 /** @internal */
 export const Base: Effectable.CommitPrimitive = (function() {

package/src/internal/fiberMessage.ts

@@ -39,10 +39,7 @@ export interface InterruptSignal {
 /** @internal */
 export interface Stateful {
   readonly _tag: OP_STATEFUL
-  readonly onFiber: (
-    fiber: FiberRuntime.FiberRuntime<any, any>,
-    status: FiberStatus.FiberStatus
-  ) => void
+  onFiber(fiber: FiberRuntime.FiberRuntime<any, any>, status: FiberStatus.FiberStatus): void
 }
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -238,7 +238,7 @@ const runBlockedRequests = <R>(self: RequestBlock.RequestBlock<R>) =>
   )
 
 /** @internal */
-export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
+export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A> {
   readonly [internalFiber.FiberTypeId] = internalFiber.fiberVariance
   readonly [internalFiber.RuntimeFiberTypeId] = runtimeFiberVariance
 
@@ -1044,7 +1044,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
   }
 
   ["None"](_: core.Primitive & { _op: "None" }) {
-    return core.fail(internalCause.NoSuchElementException())
+    return core.fail(new core.NoSuchElementException())
   }
 
   ["Right"](op: core.Primitive & { _op: "Right" }) {
@@ -1312,23 +1312,22 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
             (e as core.Primitive)._op === OpCodes.OP_ASYNC
           ) {
             throw e
-          }
-          if (
+          } else if (
             (e as core.Primitive)._op === OpCodes.OP_SUCCESS ||
             (e as core.Primitive)._op === OpCodes.OP_FAILURE
           ) {
             return e as Exit.Exit<E, A>
-          }
-        } else {
-          if (core.isEffectError(e)) {
-            cur = core.exitFailCause(e.cause)
-          } else if (internalCause.isInterruptedException(e)) {
-            cur = core.exitFailCause(
-              internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
-            )
           } else {
             cur = core.exitFailCause(internalCause.die(e))
           }
+        } else if (core.isEffectError(e)) {
+          cur = core.exitFailCause(e.cause)
+        } else if (core.isInterruptedException(e)) {
+          cur = core.exitFailCause(
+            internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
+          )
+        } else {
+          cur = core.exitFailCause(internalCause.die(e))
         }
       }
     }
@@ -2291,7 +2290,7 @@ export const partition = dual<
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
     }
-  ) => (elements: Iterable<A>) => Effect.Effect<R, never, [Array<E>, Array<B>]>,
+  ) => (elements: Iterable<A>) => Effect.Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>,
   <R, E, A, B>(
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect.Effect<R, E, B>,
@@ -2299,7 +2298,7 @@ export const partition = dual<
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
     }
-  ) => Effect.Effect<R, never, [Array<E>, Array<B>]>
+  ) => Effect.Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>
 >((args) => Predicate.isIterable(args[0]), (elements, f, options) =>
   pipe(
     forEach(elements, (a, i) => core.either(f(a, i)), options),
@@ -2369,7 +2368,7 @@ export const validateAll = dual<
 export const raceAll = <R, E, A>(all: Iterable<Effect.Effect<R, E, A>>) => {
   const list = Chunk.fromIterable(all)
   if (!Chunk.isNonEmpty(list)) {
-    return core.dieSync(() => internalCause.IllegalArgumentException(`Received an empty collection of effects`))
+    return core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`))
   }
   const self = Chunk.headNonEmpty(list)
   const effects = Chunk.tailNonEmpty(list)

package/src/internal/fiberScope.ts

@@ -24,7 +24,7 @@ export type FiberScopeTypeId = typeof FiberScopeTypeId
 export interface FiberScope {
   readonly [FiberScopeTypeId]: FiberScopeTypeId
   get fiberId(): FiberId.FiberId
-  readonly add: (runtimeFlags: RuntimeFlags.RuntimeFlags, child: FiberRuntime.FiberRuntime<any, any>) => void
+  add(runtimeFlags: RuntimeFlags.RuntimeFlags, child: FiberRuntime.FiberRuntime<any, any>): void
 }
 
 /** @internal */

package/src/internal/groupBy.ts

@@ -315,7 +315,7 @@ export const bindEffect = dual<
 
 const mapDequeue = <A, B>(dequeue: Queue.Dequeue<A>, f: (a: A) => B): Queue.Dequeue<B> => new MapDequeue(dequeue, f)
 
-class MapDequeue<A, B> implements Queue.Dequeue<B> {
+class MapDequeue<in out A, out B> implements Queue.Dequeue<B> {
   readonly [Queue.DequeueTypeId] = {
     _Out: (_: never) => _
   }

package/src/internal/hashMap/node.ts

@@ -21,7 +21,7 @@ export interface SizeRef {
 }
 
 /** @internal */
-export class EmptyNode<K, V> {
+export class EmptyNode<out K, out V> {
   readonly _tag = "EmptyNode"
 
   modify(
@@ -57,7 +57,7 @@ export function canEditNode<K, V>(node: Node<K, V>, edit: number): boolean {
 }
 
 /** @internal */
-export class LeafNode<K, V> {
+export class LeafNode<out K, out V> {
   readonly _tag = "LeafNode"
 
   constructor(
@@ -103,7 +103,7 @@ export class LeafNode<K, V> {
 }
 
 /** @internal */
-export class CollisionNode<K, V> {
+export class CollisionNode<out K, out V> {
   readonly _tag = "CollisionNode"
 
   constructor(
@@ -180,7 +180,7 @@ export class CollisionNode<K, V> {
 }
 
 /** @internal */
-export class IndexedNode<K, V> {
+export class IndexedNode<out K, out V> {
   readonly _tag = "IndexedNode"
 
   constructor(
@@ -244,7 +244,7 @@ export class IndexedNode<K, V> {
 }
 
 /** @internal */
-export class ArrayNode<K, V> {
+export class ArrayNode<out K, out V> {
   readonly _tag = "ArrayNode"
 
   constructor(

package/src/internal/hashMap.ts

@@ -34,7 +34,7 @@ interface VisitResult<K, V, A> {
 }
 
 /** @internal */
-export interface HashMapImpl<K, V> extends HM.HashMap<K, V> {
+export interface HashMapImpl<out K, out V> extends HM.HashMap<K, V> {
   _editable: boolean // mutable by design
   _edit: number // mutable by design
   _root: Node.Node<K, V> // mutable by design
@@ -106,7 +106,7 @@ const makeImpl = <K, V>(
   return map
 }
 
-class HashMapIterator<K, V, T> implements IterableIterator<T> {
+class HashMapIterator<in out K, in out V, out T> implements IterableIterator<T> {
   v: Option.Option<VisitResult<K, V, T>>
 
   constructor(readonly map: HashMapImpl<K, V>, readonly f: TraversalFn<K, V, T>) {
@@ -485,23 +485,22 @@ export const reduce = Dual.dual<
 })
 
 /** @internal */
-export const filter = Dual.dual<
-  {
-    <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
-    <K, A>(f: (a: A, k: K) => boolean): (self: HM.HashMap<K, A>) => HM.HashMap<K, A>
-  },
-  {
-    <K, A, B extends A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => a is B): HM.HashMap<K, B>
-    <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A>
-  }
->(2, <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean) =>
-  mutate(empty(), (map) => {
-    for (const [k, a] of self) {
-      if (f(a, k)) {
-        set(map, k, a)
+export const filter: {
+  <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
+  <K, B extends A, A = B>(f: (a: A, k: K) => boolean): (self: HM.HashMap<K, B>) => HM.HashMap<K, B>
+  <K, A, B extends A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => a is B): HM.HashMap<K, B>
+  <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A>
+} = Dual.dual(
+  2,
+  <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A> =>
+    mutate(empty(), (map) => {
+      for (const [k, a] of self) {
+        if (f(a, k)) {
+          set(map, k, a)
+        }
       }
-    }
-  }))
+    })
+)
 
 /** @internal */
 export const compact = <K, A>(self: HM.HashMap<K, Option.Option<A>>) => filterMap(self, identity)
@@ -524,13 +523,15 @@ export const filterMap = Dual.dual<
 
 /** @internal */
 export const findFirst: {
-  <K, A>(predicate: (k: K, a: A) => boolean): (self: HM.HashMap<K, A>) => Option.Option<[K, A]>
-  <K, A>(self: HM.HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option.Option<[K, A]>
+  <K, A, B extends A>(predicate: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => Option.Option<[K, B]>
+  <K, B extends A, A = B>(predicate: (a: A, k: K) => boolean): (self: HM.HashMap<K, B>) => Option.Option<[K, B]>
+  <K, A, B extends A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => a is B): Option.Option<[K, B]>
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option.Option<[K, A]>
 } = Dual.dual(
   2,
-  <K, A>(self: HM.HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option.Option<[K, A]> => {
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option.Option<[K, A]> => {
     for (const ka of self) {
-      if (predicate(ka[0], ka[1])) {
+      if (predicate(ka[1], ka[0])) {
         return Option.some(ka)
       }
     }

package/src/internal/hashSet.ts

@@ -15,7 +15,7 @@ const HashSetSymbolKey = "effect/HashSet"
 export const HashSetTypeId: HS.TypeId = Symbol.for(HashSetSymbolKey) as HS.TypeId
 
 /** @internal */
-export interface HashSetImpl<A> extends HS.HashSet<A> {
+export interface HashSetImpl<out A> extends HS.HashSet<A> {
   readonly _keyMap: HashMap<A, unknown>
 }
 
@@ -271,16 +271,12 @@ export const reduce = dual<
   ))
 
 /** @internal */
-export const filter = dual<
-  {
-    <A, B extends A>(f: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
-    <A>(f: Predicate<A>): (self: HS.HashSet<A>) => HS.HashSet<A>
-  },
-  {
-    <A, B extends A>(self: HS.HashSet<A>, f: Refinement<A, B>): HS.HashSet<B>
-    <A>(self: HS.HashSet<A>, f: Predicate<A>): HS.HashSet<A>
-  }
->(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
+export const filter: {
+  <A, B extends A>(refinement: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
+  <B extends A, A = B>(predicate: Predicate<B>): (self: HS.HashSet<A>) => HS.HashSet<A>
+  <A, B extends A>(self: HS.HashSet<A>, refinement: Refinement<A, B>): HS.HashSet<B>
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): HS.HashSet<A>
+} = dual(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
   return mutate(empty(), (set) => {
     const iterator = values(self)
     let next: IteratorResult<A, any>
@@ -297,25 +293,27 @@ export const filter = dual<
 export const partition: {
   <C extends A, B extends A, A = C>(
     refinement: Refinement<A, B>
-  ): (self: HS.HashSet<C>) => [HS.HashSet<Exclude<C, B>>, HS.HashSet<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: HS.HashSet<B>) => [HS.HashSet<B>, HS.HashSet<B>]
-  <C extends A, B extends A, A = C>(
-    self: HS.HashSet<C>,
+  ): (self: HS.HashSet<C>) => [excluded: HS.HashSet<Exclude<C, B>>, satisfying: HS.HashSet<B>]
+  <A, B extends A>(
+    predicate: Predicate<A>
+  ): (self: HS.HashSet<B>) => [excluded: HS.HashSet<B>, satisfying: HS.HashSet<B>]
+  <A, B extends A>(
+    self: HS.HashSet<A>,
     refinement: Refinement<A, B>
-  ): [HS.HashSet<Exclude<C, B>>, HS.HashSet<B>]
-  <B extends A, A = B>(self: HS.HashSet<B>, predicate: (a: A) => boolean): [HS.HashSet<B>, HS.HashSet<B>]
-} = dual(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
+  ): [excluded: HS.HashSet<Exclude<A, B>>, satisfying: HS.HashSet<B>]
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): [excluded: HS.HashSet<A>, satisfying: HS.HashSet<A>]
+} = dual(2, <A>(self: HS.HashSet<A>, predicate: Predicate<A>): [excluded: HS.HashSet<A>, satisfying: HS.HashSet<A>] => {
   const iterator = values(self)
   let next: IteratorResult<A, any>
   const right = beginMutation(empty<A>())
   const left = beginMutation(empty<A>())
   while (!(next = iterator.next()).done) {
     const value = next.value
-    if (f(value)) {
+    if (predicate(value)) {
       add(right, value)
     } else {
       add(left, value)
     }
   }
-  return [endMutation(left), endMutation(right)] as const
+  return [endMutation(left), endMutation(right)]
 })

package/src/internal/keyedPool.ts

@@ -30,10 +30,10 @@ type KeyedPoolMapValueSymbol = typeof KeyedPoolMapValueSymbol
 const keyedPoolVariance = {
   _K: (_: unknown) => _,
   _E: (_: never) => _,
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
-class KeyedPoolImpl<K, E, A> implements KeyedPool.KeyedPool<K, E, A> {
+class KeyedPoolImpl<in K, out E, in out A> implements KeyedPool.KeyedPool<K, E, A> {
   readonly [KeyedPoolTypeId] = keyedPoolVariance
   constructor(
     readonly getOrCreatePool: (key: K) => Effect.Effect<never, never, Pool.Pool<E, A>>,
@@ -52,7 +52,7 @@ class KeyedPoolImpl<K, E, A> implements KeyedPool.KeyedPool<K, E, A> {
 
 type MapValue<E, A> = Complete<E, A> | Pending<E, A>
 
-class Complete<E, A> implements Equal.Equal {
+class Complete<out E, in out A> implements Equal.Equal {
   readonly _tag = "Complete"
   readonly [KeyedPoolMapValueSymbol]: KeyedPoolMapValueSymbol = KeyedPoolMapValueSymbol
   constructor(readonly pool: Pool.Pool<E, A>) {}
@@ -70,7 +70,7 @@ class Complete<E, A> implements Equal.Equal {
 const isComplete = (u: unknown): u is Complete<unknown, unknown> =>
   Predicate.isTagged(u, "Complete") && KeyedPoolMapValueSymbol in u
 
-class Pending<E, A> implements Equal.Equal {
+class Pending<in out E, in out A> implements Equal.Equal {
   readonly _tag = "Pending"
   readonly [KeyedPoolMapValueSymbol]: KeyedPoolMapValueSymbol = KeyedPoolMapValueSymbol
   constructor(readonly deferred: Deferred.Deferred<never, Pool.Pool<E, A>>) {}

package/src/internal/layer.ts

@@ -82,8 +82,8 @@ export interface ExtendScope extends
 export interface Fold extends
   Op<OpCodes.OP_FOLD, {
     readonly layer: Layer.Layer<never, never, unknown>
-    readonly failureK: (cause: Cause.Cause<unknown>) => Layer.Layer<never, never, unknown>
-    readonly successK: (context: Context.Context<unknown>) => Layer.Layer<never, never, unknown>
+    failureK(cause: Cause.Cause<unknown>): Layer.Layer<never, never, unknown>
+    successK(context: Context.Context<unknown>): Layer.Layer<never, never, unknown>
   }>
 {}
 
@@ -111,7 +111,7 @@ export interface Scoped extends
 /** @internal */
 export interface Suspend extends
   Op<OpCodes.OP_SUSPEND, {
-    readonly evaluate: LazyArg<Layer.Layer<never, never, unknown>>
+    evaluate(): Layer.Layer<never, never, unknown>
   }>
 {}
 
@@ -119,7 +119,7 @@ export interface Suspend extends
 export interface Locally extends
   Op<"Locally", {
     readonly self: Layer.Layer<never, never, unknown>
-    readonly f: (_: Effect.Effect<any, any, any>) => Effect.Effect<any, any, any>
+    f(_: Effect.Effect<any, any, any>): Effect.Effect<any, any, any>
   }>
 {}
 
@@ -136,10 +136,7 @@ export interface ZipWith extends
   Op<OpCodes.OP_ZIP_WITH, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
-    readonly zipK: (
-      left: Context.Context<unknown>,
-      right: Context.Context<unknown>
-    ) => Context.Context<unknown>
+    zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
   }>
 {}
 
@@ -148,10 +145,7 @@ export interface ZipWithPar extends
   Op<OpCodes.OP_ZIP_WITH_PAR, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
-    readonly zipK: (
-      left: Context.Context<unknown>,
-      right: Context.Context<unknown>
-    ) => Context.Context<unknown>
+    zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
   }>
 {}
 

package/src/internal/metric/key.ts

@@ -28,7 +28,7 @@ const metricKeyVariance = {
 }
 
 /** @internal */
-class MetricKeyImpl<Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
+class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
   readonly [MetricKeyTypeId] = metricKeyVariance
   constructor(
     readonly name: string,

package/src/internal/metric/polling.ts

@@ -2,7 +2,7 @@ import type * as Effect from "../../Effect.js"
 import type * as Fiber from "../../Fiber.js"
 import { dual, pipe } from "../../Function.js"
 import type * as Metric from "../../Metric.js"
-import type * as PollingMetric from "../../MetricPolling.js"
+import type * as MetricPolling from "../../MetricPolling.js"
 import { pipeArguments } from "../../Pipeable.js"
 import type * as Schedule from "../../Schedule.js"
 import type * as Scope from "../../Scope.js"
@@ -12,20 +12,20 @@ import * as metric from "../metric.js"
 import * as schedule from "../schedule.js"
 
 /** @internal */
-const PollingMetricSymbolKey = "effect/MetricPolling"
+const MetricPollingSymbolKey = "effect/MetricPolling"
 
 /** @internal */
-export const PollingMetricTypeId: PollingMetric.PollingMetricTypeId = Symbol.for(
-  PollingMetricSymbolKey
-) as PollingMetric.PollingMetricTypeId
+export const MetricPollingTypeId: MetricPolling.MetricPollingTypeId = Symbol.for(
+  MetricPollingSymbolKey
+) as MetricPolling.MetricPollingTypeId
 
 /** @internal */
 export const make = <Type, In, Out, R, E>(
   metric: Metric.Metric<Type, In, Out>,
   poll: Effect.Effect<R, E, In>
-): PollingMetric.PollingMetric<Type, In, R, E, Out> => {
+): MetricPolling.MetricPolling<Type, In, R, E, Out> => {
   return {
-    [PollingMetricTypeId]: PollingMetricTypeId,
+    [MetricPollingTypeId]: MetricPollingTypeId,
     pipe() {
       return pipeArguments(this, arguments)
     },
@@ -36,11 +36,11 @@ export const make = <Type, In, Out, R, E>(
 
 /** @internal */
 export const collectAll = <R, E, Out>(
-  iterable: Iterable<PollingMetric.PollingMetric<any, any, R, E, Out>>
-): PollingMetric.PollingMetric<Array<any>, Array<any>, R, E, Array<Out>> => {
+  iterable: Iterable<MetricPolling.MetricPolling<any, any, R, E, Out>>
+): MetricPolling.MetricPolling<Array<any>, Array<any>, R, E, Array<Out>> => {
   const metrics = Array.from(iterable)
   return {
-    [PollingMetricTypeId]: PollingMetricTypeId,
+    [MetricPollingTypeId]: MetricPollingTypeId,
     pipe() {
       return pipeArguments(this, arguments)
     },
@@ -67,10 +67,10 @@ export const launch = dual<
   <R2, A2>(
     schedule: Schedule.Schedule<R2, unknown, A2>
   ) => <Type, In, R, E, Out>(
-    self: PollingMetric.PollingMetric<Type, In, R, E, Out>
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => Effect.Effect<R | R2 | Scope.Scope, never, Fiber.Fiber<E, A2>>,
   <Type, In, R, E, Out, R2, A2>(
-    self: PollingMetric.PollingMetric<Type, In, R, E, Out>,
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
     schedule: Schedule.Schedule<R2, unknown, A2>
   ) => Effect.Effect<R | R2 | Scope.Scope, never, Fiber.Fiber<E, A2>>
 >(2, (self, schedule) =>
@@ -82,12 +82,12 @@ export const launch = dual<
 
 /** @internal */
 export const poll = <Type, In, R, E, Out>(
-  self: PollingMetric.PollingMetric<Type, In, R, E, Out>
+  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
 ): Effect.Effect<R, E, In> => self.poll
 
 /** @internal */
 export const pollAndUpdate = <Type, In, R, E, Out>(
-  self: PollingMetric.PollingMetric<Type, In, R, E, Out>
+  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
 ): Effect.Effect<R, E, void> => core.flatMap(self.poll, (value) => metric.update(self.metric, value))
 
 /** @internal */
@@ -95,14 +95,14 @@ export const retry = dual<
   <R2, E, _>(
     policy: Schedule.Schedule<R2, E, _>
   ) => <Type, In, R, Out>(
-    self: PollingMetric.PollingMetric<Type, In, R, E, Out>
-  ) => PollingMetric.PollingMetric<Type, In, R | R2, E, Out>,
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
   <Type, In, R, Out, R2, E, _>(
-    self: PollingMetric.PollingMetric<Type, In, R, E, Out>,
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
     policy: Schedule.Schedule<R2, E, _>
-  ) => PollingMetric.PollingMetric<Type, In, R | R2, E, Out>
+  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
 >(2, (self, policy) => ({
-  [PollingMetricTypeId]: PollingMetricTypeId,
+  [MetricPollingTypeId]: MetricPollingTypeId,
   pipe() {
     return pipeArguments(this, arguments)
   },
@@ -113,10 +113,10 @@ export const retry = dual<
 /** @internal */
 export const zip = dual<
   <Type2, In2, R2, E2, Out2>(
-    that: PollingMetric.PollingMetric<Type2, In2, R2, E2, Out2>
+    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
   ) => <Type, In, R, E, Out>(
-    self: PollingMetric.PollingMetric<Type, In, R, E, Out>
-  ) => PollingMetric.PollingMetric<
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling.MetricPolling<
     readonly [Type, Type2],
     readonly [In, In2],
     R | R2,
@@ -124,9 +124,9 @@ export const zip = dual<
     [Out, Out2]
   >,
   <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
-    self: PollingMetric.PollingMetric<Type, In, R, E, Out>,
-    that: PollingMetric.PollingMetric<Type2, In2, R2, E2, Out2>
-  ) => PollingMetric.PollingMetric<
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
+  ) => MetricPolling.MetricPolling<
     readonly [Type, Type2],
     readonly [In, In2],
     R | R2,
@@ -134,7 +134,7 @@ export const zip = dual<
     [Out, Out2]
   >
 >(2, (self, that) => ({
-  [PollingMetricTypeId]: PollingMetricTypeId,
+  [MetricPollingTypeId]: MetricPollingTypeId,
   pipe() {
     return pipeArguments(this, arguments)
   },

package/src/internal/metric.ts

@@ -63,6 +63,10 @@ export const make: Metric.MetricApply = function<Type, In, Out>(
       keyType,
       unsafeUpdate,
       unsafeValue,
+      register() {
+        this.unsafeValue(HashSet.empty())
+        return this as any
+      },
       pipe() {
         return pipeArguments(this, arguments)
       }

package/src/internal/pool.ts

@@ -29,7 +29,7 @@ export const PoolTypeId: Pool.PoolTypeId = Symbol.for(
 
 const poolVariance = {
   _E: (_: never) => _,
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 interface PoolState {
@@ -131,7 +131,7 @@ class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<numb
   }
 }
 
-class PoolImpl<E, A> implements Pool.Pool<E, A> {
+class PoolImpl<in out E, in out A> implements Pool.Pool<E, A> {
   readonly [PoolTypeId] = poolVariance
   constructor(
     readonly creator: Effect.Effect<Scope.Scope, E, A>,