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

package/src/Resource.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/resource.js"
 import type * as Schedule from "./Schedule.js"
 import type * as Scope from "./Scope.js"
 import type * as ScopedRef from "./ScopedRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -27,7 +28,7 @@ export type ResourceTypeId = typeof ResourceTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Resource<E, A> extends Resource.Variance<E, A> {
+export interface Resource<in out E, in out A> extends Resource.Variance<E, A> {
   /** @internal */
   readonly scopedRef: ScopedRef.ScopedRef<Exit.Exit<E, A>>
   /** @internal */
@@ -42,10 +43,10 @@ export declare namespace Resource {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<in out E, in out A> {
     readonly [ResourceTypeId]: {
-      _E: (_: never) => E
-      _A: (_: never) => A
+      _E: Types.Invariant<E>
+      _A: Types.Invariant<A>
     }
   }
 }

package/src/Runtime.ts

@@ -18,7 +18,7 @@ import type { Scheduler } from "./Scheduler.js"
  * @since 2.0.0
  * @category models
  */
-export interface AsyncFiberException<E, A> {
+export interface AsyncFiberException<out E, out A> {
   readonly _tag: "AsyncFiberException"
   readonly fiber: Fiber.RuntimeFiber<E, A>
 }
@@ -27,7 +27,7 @@ export interface AsyncFiberException<E, A> {
  * @since 2.0.0
  * @category models
  */
-export interface Cancel<E, A> {
+export interface Cancel<out E, out A> {
   (fiberId?: FiberId.FiberId, onExit?: (exit: Exit.Exit<E, A>) => void): void
 }
 
@@ -35,7 +35,7 @@ export interface Cancel<E, A> {
  * @since 2.0.0
  * @category models
  */
-export interface Runtime<R> extends Pipeable {
+export interface Runtime<in R> extends Pipeable {
   /**
    * The context used as initial for forks
    */

package/src/STM.ts

@@ -14,6 +14,7 @@ import * as stm from "./internal/stm/stm.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -65,7 +66,7 @@ export type STMTypeId = typeof STMTypeId
  * @since 2.0.0
  * @category models
  */
-export interface STM<R, E, A> extends Effect.Effect<R, E, A>, STM.Variance<R, E, A>, Pipeable {
+export interface STM<out R, out E, out A> extends Effect.Effect<R, E, A>, STM.Variance<R, E, A>, Pipeable {
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: STMUnify<this>
   [Unify.ignoreSymbol]?: STMUnifyIgnore
@@ -137,11 +138,11 @@ export declare namespace STM {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, A> {
+  export interface Variance<out R, out E, out A> {
     readonly [STMTypeId]: {
-      readonly _R: (_: never) => R
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _R: Types.Covariant<R>
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 }
@@ -150,12 +151,12 @@ export declare namespace STM {
  * @category models
  * @since 2.0.0
  */
-export interface STMGen<R, E, A> {
+export interface STMGen<out R, out E, out A> {
   readonly _R: () => R
   readonly _E: () => E
   readonly _A: () => A
   readonly value: STM<R, E, A>
-  readonly [Symbol.iterator]: () => Generator<STMGen<R, E, A>, A>
+  [Symbol.iterator](): Generator<STMGen<R, E, A>, A>
 }
 
 /**
@@ -1208,7 +1209,7 @@ export const isSuccess: <R, E, A>(self: STM<R, E, A>) => STM<R, never, boolean>
 export const iterate: <R, E, Z>(
   initial: Z,
   options: {
-    readonly while: (z: Z) => boolean
+    readonly while: Predicate<Z>
     readonly body: (z: Z) => STM<R, E, Z>
   }
 ) => STM<R, E, Z> = stm.iterate
@@ -1236,7 +1237,7 @@ export const loop: {
   <Z, R, E, A>(
     initial: Z,
     options: {
-      readonly while: (z: Z) => boolean
+      readonly while: Predicate<Z>
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => STM<R, E, A>
       readonly discard?: false | undefined
@@ -1245,7 +1246,7 @@ export const loop: {
   <Z, R, E, A>(
     initial: Z,
     options: {
-      readonly while: (z: Z) => boolean
+      readonly while: Predicate<Z>
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => STM<R, E, A>
       readonly discard: true
@@ -1465,8 +1466,13 @@ export const orTry: {
  * @category traversing
  */
 export const partition: {
-  <R, E, A, A2>(f: (a: A) => STM<R, E, A2>): (elements: Iterable<A>) => STM<R, never, [Array<E>, Array<A2>]>
-  <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>): STM<R, never, [Array<E>, Array<A2>]>
+  <R, E, A, A2>(
+    f: (a: A) => STM<R, E, A2>
+  ): (elements: Iterable<A>) => STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
+  <R, E, A, A2>(
+    elements: Iterable<A>,
+    f: (a: A) => STM<R, E, A2>
+  ): STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
 } = stm.partition
 
 /**
@@ -1823,11 +1829,17 @@ export const tap: {
  */
 export const tapBoth: {
   <E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
-    options: { readonly onFailure: (error: XE) => STM<R2, E2, A2>; readonly onSuccess: (value: XA) => STM<R3, E3, A3> }
+    options: {
+      readonly onFailure: (error: XE) => STM<R2, E2, A2>
+      readonly onSuccess: (value: XA) => STM<R3, E3, A3>
+    }
   ): <R>(self: STM<R, E, A>) => STM<R2 | R3 | R, E | E2 | E3, A>
   <R, E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
     self: STM<R, E, A>,
-    options: { readonly onFailure: (error: XE) => STM<R2, E2, A2>; readonly onSuccess: (value: XA) => STM<R3, E3, A3> }
+    options: {
+      readonly onFailure: (error: XE) => STM<R2, E2, A2>
+      readonly onSuccess: (value: XA) => STM<R3, E3, A3>
+    }
   ): STM<R | R2 | R3, E | E2 | E3, A>
 } = stm.tapBoth
 
@@ -2026,7 +2038,7 @@ export const firstSuccessOf = <R, E, A>(effects: Iterable<STM<R, E, A>>): STM<R,
   suspend<R, E, A>(() => {
     const list = Chunk.fromIterable(effects)
     if (!Chunk.isNonEmpty(list)) {
-      return dieSync(() => Cause.IllegalArgumentException(`Received an empty collection of effects`))
+      return dieSync(() => new Cause.IllegalArgumentException(`Received an empty collection of effects`))
     }
     return Chunk.reduce(
       Chunk.tailNonEmpty(list),

package/src/Schedule.ts

@@ -14,6 +14,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.js"
 import type * as ScheduleDecision from "./ScheduleDecision.js"
 import type * as Intervals from "./ScheduleIntervals.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -67,7 +68,7 @@ export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId
  * @category model
  * @since 2.0.0
  */
-export interface Schedule<Env, In, Out> extends Schedule.Variance<Env, In, Out>, Pipeable {
+export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env, In, Out>, Pipeable {
   /**
    * Initial State
    */
@@ -75,11 +76,11 @@ export interface Schedule<Env, In, Out> extends Schedule.Variance<Env, In, Out>,
   /**
    * Schedule Step
    */
-  readonly step: (
+  step(
     now: number,
     input: In,
     state: any
-  ) => Effect.Effect<Env, never, readonly [any, Out, ScheduleDecision.ScheduleDecision]>
+  ): Effect.Effect<Env, never, readonly [any, Out, ScheduleDecision.ScheduleDecision]>
 }
 
 /**
@@ -90,22 +91,22 @@ export declare namespace Schedule {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Env, In, Out> {
+  export interface Variance<out Env, in In, out Out> {
     readonly [ScheduleTypeId]: {
-      readonly _Env: (_: never) => Env
-      readonly _In: (_: In) => void
-      readonly _Out: (_: never) => Out
+      readonly _Env: Types.Covariant<Env>
+      readonly _In: Types.Contravariant<In>
+      readonly _Out: Types.Covariant<Out>
     }
   }
 
   /**
    * @since 2.0.0
    */
-  export interface DriverVariance<Env, In, Out> {
+  export interface DriverVariance<out Env, in In, out Out> {
     readonly [ScheduleDriverTypeId]: {
-      readonly _Env: (_: never) => Env
-      readonly _In: (_: In) => void
-      readonly _Out: (_: never) => Out
+      readonly _Env: Types.Covariant<Env>
+      readonly _In: Types.Contravariant<In>
+      readonly _Out: Types.Covariant<Out>
     }
   }
 }
@@ -114,11 +115,11 @@ export declare namespace Schedule {
  * @since 2.0.0
  * @category models
  */
-export interface ScheduleDriver<Env, In, Out> extends Schedule.DriverVariance<Env, In, Out> {
+export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.DriverVariance<Env, In, Out> {
   readonly state: Effect.Effect<never, never, unknown>
   readonly last: Effect.Effect<never, Cause.NoSuchElementException, Out>
   readonly reset: Effect.Effect<never, never, void>
-  readonly next: (input: In) => Effect.Effect<Env, Option.Option<never>, Out>
+  next(input: In): Effect.Effect<Env, Option.Option<never>, Out>
 }
 
 /**

package/src/Scheduler.ts

@@ -21,15 +21,15 @@ export type Task = () => void
  * @category models
  */
 export interface Scheduler {
-  readonly shouldYield: (fiber: RuntimeFiber<unknown, unknown>) => number | false
-  readonly scheduleTask: (task: Task, priority: number) => void
+  shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false
+  scheduleTask(task: Task, priority: number): void
 }
 
 /**
  * @since 2.0.0
  * @category utils
  */
-export class PriorityBuckets<T = Task> {
+export class PriorityBuckets<in out T = Task> {
   /**
    * @since 2.0.0
    */

package/src/Scope.ts

@@ -44,11 +44,11 @@ export interface Scope extends Pipeable {
   /**
    * @internal
    */
-  readonly fork: (strategy: ExecutionStrategy.ExecutionStrategy) => Effect.Effect<never, never, Scope.Closeable>
+  fork(strategy: ExecutionStrategy.ExecutionStrategy): Effect.Effect<never, never, Scope.Closeable>
   /**
    * @internal
    */
-  readonly addFinalizer: (finalizer: Scope.Finalizer) => Effect.Effect<never, never, void>
+  addFinalizer(finalizer: Scope.Finalizer): Effect.Effect<never, never, void>
 }
 
 /**
@@ -61,7 +61,7 @@ export interface CloseableScope extends Scope, Pipeable {
   /**
    * @internal
    */
-  readonly close: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never, never, void>
 }
 
 /**

package/src/ScopedCache.ts

@@ -9,6 +9,7 @@ import * as internal from "./internal/scopedCache.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -26,18 +27,18 @@ export type ScopedCacheTypeId = typeof ScopedCacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedCache<Key, Error, Value> extends ScopedCache.Variance<Key, Error, Value>, Pipeable {
+export interface ScopedCache<in Key, out Error, out Value> extends ScopedCache.Variance<Key, Error, Value>, Pipeable {
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
    */
-  readonly getOption: (key: Key) => Effect.Effect<Scope.Scope, Error, Option.Option<Value>>
+  getOption(key: Key): Effect.Effect<Scope.Scope, Error, Option.Option<Value>>
 
   /**
    * Retrieves the value associated with the specified key if it exists and the
    * lookup function has completed. Otherwise returns `Option.none`.
    */
-  readonly getOptionComplete: (key: Key) => Effect.Effect<Scope.Scope, never, Option.Option<Value>>
+  getOptionComplete(key: Key): Effect.Effect<Scope.Scope, never, Option.Option<Value>>
 
   /**
    * Returns statistics for this cache.
@@ -49,24 +50,24 @@ export interface ScopedCache<Key, Error, Value> extends ScopedCache.Variance<Key
    * cache. Sometime `contains` can return true if the resource is currently
    * being created but not yet totally created.
    */
-  readonly contains: (key: Key) => Effect.Effect<never, never, boolean>
+  contains(key: Key): Effect.Effect<never, never, boolean>
 
   /**
    * Return statistics for the specified entry.
    */
-  readonly entryStats: (key: Key) => Effect.Effect<never, never, Option.Option<Cache.EntryStats>>
+  entryStats(key: Key): Effect.Effect<never, never, Option.Option<Cache.EntryStats>>
 
   /**
    * Gets the value from the cache if it exists or otherwise computes it, the
    * release action signals to the cache that the value is no longer being used
    * and can potentially be finalized subject to the policies of the cache.
    */
-  readonly get: (key: Key) => Effect.Effect<Scope.Scope, Error, Value>
+  get(key: Key): Effect.Effect<Scope.Scope, Error, Value>
 
   /**
    * Invalidates the resource associated with the specified key.
    */
-  readonly invalidate: (key: Key) => Effect.Effect<never, never, void>
+  invalidate(key: Key): Effect.Effect<never, never, void>
 
   /**
    * Invalidates all values in the cache.
@@ -81,7 +82,7 @@ export interface ScopedCache<Key, Error, Value> extends ScopedCache.Variance<Key
    * computed, concurrent call the .get will use the old resource if this one is
    * not expired.
    */
-  readonly refresh: (key: Key) => Effect.Effect<never, Error, void>
+  refresh(key: Key): Effect.Effect<never, Error, void>
 
   /**
    * Returns the approximate number of values in the cache.
@@ -97,11 +98,11 @@ export declare namespace ScopedCache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Key, Error, Value> {
+  export interface Variance<in Key, out Error, out Value> {
     readonly [ScopedCacheTypeId]: {
-      _Key: (_: Key) => void
-      _Error: (_: never) => Error
-      _Value: (_: never) => Value
+      _Key: Types.Contravariant<Key>
+      _Error: Types.Covariant<Error>
+      _Value: Types.Covariant<Value>
     }
   }
 }

package/src/ScopedRef.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/scopedRef.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
 import type * as Synchronized from "./SynchronizedRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -30,7 +31,7 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedRef<A> extends ScopedRef.Variance<A>, Pipeable {
+export interface ScopedRef<in out A> extends ScopedRef.Variance<A>, Pipeable {
   /** @internal */
   readonly ref: Synchronized.SynchronizedRef<readonly [Scope.Scope.Closeable, A]>
 }
@@ -43,9 +44,9 @@ export declare namespace ScopedRef {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [ScopedRefTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/SingleProducerAsyncInput.ts

@@ -26,7 +26,7 @@ import * as internal from "./internal/channel/singleProducerAsyncInput.js"
  * @since 2.0.0
  * @category models
  */
-export interface SingleProducerAsyncInput<Err, Elem, Done>
+export interface SingleProducerAsyncInput<in out Err, in out Elem, in out Done>
   extends AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done>
 {
   readonly close: Effect.Effect<never, never, unknown>
@@ -39,11 +39,11 @@ export interface SingleProducerAsyncInput<Err, Elem, Done>
  * @since 2.0.0
  * @category models
  */
-export interface AsyncInputProducer<Err, Elem, Done> {
-  readonly awaitRead: () => Effect.Effect<never, never, unknown>
-  readonly done: (value: Done) => Effect.Effect<never, never, unknown>
-  readonly emit: (element: Elem) => Effect.Effect<never, never, unknown>
-  readonly error: (cause: Cause.Cause<Err>) => Effect.Effect<never, never, unknown>
+export interface AsyncInputProducer<in Err, in Elem, in Done> {
+  awaitRead(): Effect.Effect<never, never, unknown>
+  done(value: Done): Effect.Effect<never, never, unknown>
+  emit(element: Elem): Effect.Effect<never, never, unknown>
+  error(cause: Cause.Cause<Err>): Effect.Effect<never, never, unknown>
 }
 
 /**
@@ -52,7 +52,7 @@ export interface AsyncInputProducer<Err, Elem, Done> {
  * @since 2.0.0
  * @category models
  */
-export interface AsyncInputConsumer<Err, Elem, Done> {
+export interface AsyncInputConsumer<out Err, out Elem, out Done> {
   takeWith<A>(
     onError: (cause: Cause.Cause<Err>) => A,
     onElement: (element: Elem) => A,

package/src/Sink.ts

@@ -20,6 +20,7 @@ import type { Predicate, Refinement } from "./Predicate.js"
 import type * as PubSub from "./PubSub.js"
 import type * as Queue from "./Queue.js"
 import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -44,7 +45,7 @@ export type SinkTypeId = typeof SinkTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Sink<R, E, In, L, Z> extends Sink.Variance<R, E, In, L, Z>, Pipeable {}
+export interface Sink<out R, out E, in In, out L, out Z> extends Sink.Variance<R, E, In, L, Z>, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -90,19 +91,19 @@ export declare namespace Sink {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, In, L, Z> {
+  export interface Variance<out R, out E, in In, out L, out Z> {
     readonly [SinkTypeId]: VarianceStruct<R, E, In, L, Z>
   }
   /**
    * @since 2.0.0
    * @category models
    */
-  export interface VarianceStruct<R, E, In, L, Z> {
-    _R: (_: never) => R
-    _E: (_: never) => E
-    _In: (_: In) => void
-    _L: (_: never) => L
-    _Z: (_: never) => Z
+  export interface VarianceStruct<out R, out E, in In, out L, out Z> {
+    _R: Types.Covariant<R>
+    _E: Types.Covariant<E>
+    _In: Types.Contravariant<In>
+    _L: Types.Covariant<L>
+    _Z: Types.Covariant<Z>
   }
 }
 
@@ -215,8 +216,10 @@ export const collectAllUntilEffect: <In, R, E>(
  * @since 2.0.0
  * @category constructors
  */
-export const collectAllWhile: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, Chunk.Chunk<In>> =
-  internal.collectAllWhile
+export const collectAllWhile: {
+  <In, Out extends In>(refinement: Refinement<In, Out>): Sink<never, never, In, In, Chunk.Chunk<Out>>
+  <In>(predicate: Predicate<In>): Sink<never, never, In, In, Chunk.Chunk<In>>
+} = internal.collectAllWhile
 
 /**
  * Accumulates incoming elements into a chunk as long as they verify effectful
@@ -356,11 +359,17 @@ export const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, never, unknown
  */
 export const dimap: {
   <In0, In, Z, Z2>(
-    options: { readonly onInput: (input: In0) => In; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (input: In0) => In
+      readonly onDone: (z: Z) => Z2
+    }
   ): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>
   <R, E, L, In0, In, Z, Z2>(
     self: Sink<R, E, In, L, Z>,
-    options: { readonly onInput: (input: In0) => In; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (input: In0) => In
+      readonly onDone: (z: Z) => Z2
+    }
   ): Sink<R, E, In0, L, Z2>
 } = internal.dimap
 
@@ -396,11 +405,17 @@ export const dimapEffect: {
  */
 export const dimapChunks: {
   <In0, In, Z, Z2>(
-    options: { readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
+      readonly onDone: (z: Z) => Z2
+    }
   ): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>
   <R, E, L, In0, In, Z, Z2>(
     self: Sink<R, E, In, L, Z>,
-    options: { readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
+      readonly onDone: (z: Z) => Z2
+    }
   ): Sink<R, E, In0, L, Z2>
 } = internal.dimapChunks
 

package/src/SortedMap.ts

@@ -5,13 +5,14 @@ import * as Equal from "./Equal.js"
 import * as Dual from "./Function.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import { hasProperty } from "./Predicate.js"
 import * as RBT from "./RedBlackTree.js"
+import type * as Types from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedMap")
 
@@ -25,14 +26,20 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface SortedMap<K, V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
+export interface SortedMap<in out K, out V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _K: Types.Invariant<K>
+    readonly _V: Types.Covariant<V>
+  }
   /** @internal */
   readonly tree: RBT.RedBlackTree<K, V>
 }
 
 const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
-  [TypeId]: TypeId,
+  [TypeId]: {
+    _K: (_: any) => _,
+    _V: (_: never) => _
+  },
   [Hash.symbol]<K, V>(this: SortedMap<K, V>): number {
     return pipe(Hash.hash(this.tree), Hash.combine(Hash.hash("effect/SortedMap")))
   },
@@ -43,7 +50,7 @@ const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
     return this.tree[Symbol.iterator]()
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {