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

package/src/PubSub.ts

@@ -15,18 +15,18 @@ import type * as Scope from "./Scope.js"
  * @since 2.0.0
  * @category models
  */
-export interface PubSub<A> extends Queue.Enqueue<A>, Pipeable {
+export interface PubSub<in out A> extends Queue.Enqueue<A>, Pipeable {
   /**
    * Publishes a message to the `PubSub`, returning whether the message was published
    * to the `PubSub`.
    */
-  readonly publish: (value: A) => Effect.Effect<never, never, boolean>
+  publish(value: A): Effect.Effect<never, never, boolean>
 
   /**
    * Publishes all of the specified messages to the `PubSub`, returning whether they
    * were published to the `PubSub`.
    */
-  readonly publishAll: (elements: Iterable<A>) => Effect.Effect<never, never, boolean>
+  publishAll(elements: Iterable<A>): Effect.Effect<never, never, boolean>
 
   /**
    * Subscribes to receive messages from the `PubSub`. The resulting subscription can

package/src/Queue.ts

@@ -46,11 +46,23 @@ export const QueueStrategyTypeId: unique symbol = internal.QueueStrategyTypeId
  */
 export type QueueStrategyTypeId = typeof QueueStrategyTypeId
 
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const BackingQueueTypeId: unique symbol = internal.BackingQueueTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type BackingQueueTypeId = typeof BackingQueueTypeId
+
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Queue<A> extends Enqueue<A>, Dequeue<A>, Pipeable {
+export interface Queue<in out A> extends Enqueue<A>, Dequeue<A>, Pipeable {
   /** @internal */
   readonly queue: BackingQueue<A>
   /** @internal */
@@ -67,16 +79,16 @@ export interface Queue<A> extends Enqueue<A>, Dequeue<A>, Pipeable {
  * @since 2.0.0
  * @category models
  */
-export interface Enqueue<A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipeable {
+export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipeable {
   /**
    * Places one value in the queue.
    */
-  readonly offer: (value: A) => Effect.Effect<never, never, boolean>
+  offer(value: A): Effect.Effect<never, never, boolean>
 
   /**
    * Places one value in the queue when possible without needing the fiber runtime.
    */
-  readonly unsafeOffer: (value: A) => boolean
+  unsafeOffer(value: A): boolean
 
   /**
    * For Bounded Queue: uses the `BackPressure` Strategy, places the values in
@@ -93,14 +105,14 @@ export interface Enqueue<A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipeabl
    * For Dropping Queue: uses `Dropping` Strategy, It places the values in the
    * queue but if there is no room it will not enqueue them and return false.
    */
-  readonly offerAll: (iterable: Iterable<A>) => Effect.Effect<never, never, boolean>
+  offerAll(iterable: Iterable<A>): Effect.Effect<never, never, boolean>
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Dequeue<A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeable {
+export interface Dequeue<out A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeable {
   /**
    * Takes the oldest value in the queue. If the queue is empty, this will return
    * a computation that resumes when an item has been added to the queue.
@@ -116,14 +128,14 @@ export interface Dequeue<A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeabl
   /**
    * Takes up to max number of values from the queue.
    */
-  readonly takeUpTo: (max: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  takeUpTo(max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
 
   /**
    * Takes a number of elements from the queue between the specified minimum and
    * maximum. If there are fewer than the minimum number of elements available,
    * suspends until at least the minimum number of elements have been collected.
    */
-  readonly takeBetween: (min: number, max: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  takeBetween(min: number, max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
 }
 
 /**
@@ -136,12 +148,12 @@ export interface BaseQueue {
   /**
    * Returns the number of elements the queue can hold.
    */
-  readonly capacity: () => number
+  capacity(): number
 
   /**
    * Returns false if shutdown has been called.
    */
-  readonly isActive: () => boolean
+  isActive(): boolean
 
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
@@ -155,7 +167,7 @@ export interface BaseQueue {
    * in the queue. This may be negative if fibers are suspended waiting for
    * elements to be added to the queue. Returns None if shutdown has been called
    */
-  readonly unsafeSize: () => Option.Option<number>
+  unsafeSize(): Option.Option<number>
 
   /**
    * Returns `true` if the `Queue` contains at least one element, `false`
@@ -191,12 +203,12 @@ export interface BaseQueue {
  * @since 2.0.0
  * @category models
  */
-export interface Strategy<A> extends Queue.StrategyVariance<A> {
+export interface Strategy<in out A> extends Queue.StrategyVariance<A> {
   /**
    * Returns the number of surplus values that were unable to be added to the
    * `Queue`
    */
-  readonly surplusSize: () => number
+  surplusSize(): number
 
   /**
    * Determines how the `Queue.Strategy` should shut down when the `Queue` is
@@ -209,68 +221,68 @@ export interface Strategy<A> extends Queue.StrategyVariance<A> {
    * values that could not be added to the `Queue` following an `offer`
    * operation.
    */
-  readonly handleSurplus: (
+  handleSurplus(
     iterable: Iterable<A>,
     queue: BackingQueue<A>,
     takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ) => Effect.Effect<never, never, boolean>
+  ): Effect.Effect<never, never, boolean>
 
   /**
    * It is called when the backing queue is empty but there are some
    * takers that can be completed
    */
-  readonly onCompleteTakersWithEmptyQueue: (
+  onCompleteTakersWithEmptyQueue(
     takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
-  ) => void
+  ): void
 
   /**
    * Determines the behavior of the `Queue.Strategy` when the `Queue` has empty
    * slots following a `take` operation.
    */
-  readonly unsafeOnQueueEmptySpace: (
+  unsafeOnQueueEmptySpace(
     queue: BackingQueue<A>,
     takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
-  ) => void
+  ): void
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface BackingQueue<A> {
+export interface BackingQueue<in out A> extends Queue.BackingQueueVariance<A> {
   /**
    * Dequeues an element from the queue.
    * Returns either an element from the queue, or the `def` param.
    */
-  readonly poll: <Def>(def: Def) => A | Def
+  poll<Def>(def: Def): A | Def
   /**
    * Dequeues up to `limit` elements from the queue.
    */
-  readonly pollUpTo: (limit: number) => Chunk.Chunk<A>
+  pollUpTo(limit: number): Chunk.Chunk<A>
   /**
    * Enqueues a collection of values into the queue.
    *
    * Returns a `Chunk` of the values that were **not** able to be enqueued.
    */
-  readonly offerAll: (elements: Iterable<A>) => Chunk.Chunk<A>
+  offerAll(elements: Iterable<A>): Chunk.Chunk<A>
   /**
    * Offers an element to the queue.
    *
    * Returns whether the enqueue was successful or not.
    */
-  readonly offer: (element: A) => boolean
+  offer(element: A): boolean
   /**
    * The **maximum** number of elements that a queue can hold.
    *
    * **Note**: unbounded queues can still implement this interface with
    * `capacity = Infinity`.
    */
-  readonly capacity: () => number
+  capacity(): number
   /**
    * Returns the number of elements currently in the queue
    */
-  readonly length: () => number
+  length(): number
 }
 
 /**
@@ -281,7 +293,7 @@ export declare namespace Queue {
    * @since 2.0.0
    * @category models
    */
-  export interface EnqueueVariance<A> {
+  export interface EnqueueVariance<in A> {
     readonly [EnqueueTypeId]: {
       readonly _In: (_: A) => void
     }
@@ -291,7 +303,7 @@ export declare namespace Queue {
    * @since 2.0.0
    * @category models
    */
-  export interface DequeueVariance<A> {
+  export interface DequeueVariance<out A> {
     readonly [DequeueTypeId]: {
       readonly _Out: (_: never) => A
     }
@@ -301,9 +313,19 @@ export declare namespace Queue {
    * @since 2.0.0
    * @category models
    */
-  export interface StrategyVariance<A> {
+  export interface StrategyVariance<in out A> {
     readonly [QueueStrategyTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: (_: A) => A
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface BackingQueueVariance<in out A> {
+    readonly [BackingQueueTypeId]: {
+      readonly _A: (_: A) => A
     }
   }
 }

package/src/Random.ts

@@ -40,16 +40,16 @@ export interface Random {
    * Returns the next numeric value in the specified range from the
    * pseudo-random number generator.
    */
-  readonly nextRange: (min: number, max: number) => Effect.Effect<never, never, number>
+  nextRange(min: number, max: number): Effect.Effect<never, never, number>
   /**
    * Returns the next integer value in the specified range from the
    * pseudo-random number generator.
    */
-  readonly nextIntBetween: (min: number, max: number) => Effect.Effect<never, never, number>
+  nextIntBetween(min: number, max: number): Effect.Effect<never, never, number>
   /**
    * Uses the pseudo-random number generator to shuffle the specified iterable.
    */
-  readonly shuffle: <A>(elements: Iterable<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  shuffle<A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>>
 }
 
 /**

package/src/ReadonlyArray.ts

@@ -444,7 +444,7 @@ export const unsafeGet: {
  */
 export const unprepend = <A>(
   self: NonEmptyReadonlyArray<A>
-): [A, Array<A>] => [headNonEmpty(self), tailNonEmpty(self)]
+): [firstElement: A, remainingElements: Array<A>] => [headNonEmpty(self), tailNonEmpty(self)]
 
 /**
  * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element.
@@ -454,7 +454,7 @@ export const unprepend = <A>(
  */
 export const unappend = <A>(
   self: NonEmptyReadonlyArray<A>
-): [Array<A>, A] => [initNonEmpty(self), lastNonEmpty(self)]
+): [arrayWithoutLastElement: Array<A>, lastElement: A] => [initNonEmpty(self), lastNonEmpty(self)]
 
 /**
  * Get the first element of a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
@@ -562,11 +562,11 @@ export const takeRight: {
  */
 export const takeWhile: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Array<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Array<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Array<B>
   <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Array<B>
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Array<B>
-} = dual(2, <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Array<B> => {
-  const out: Array<B> = []
+  <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A>
+} = dual(2, <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A> => {
+  const out: Array<A> = []
   for (const a of self) {
     if (!predicate(a)) {
       break
@@ -597,18 +597,15 @@ const spanIndex = <A>(self: Iterable<A>, predicate: Predicate<A>): number => {
  * @since 2.0.0
  */
 export const span: {
-  <A, B extends A>(
-    refinement: Refinement<A, B>
-  ): (self: Iterable<A>) => [init: Array<B>, rest: Array<A>]
-  <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => [init: Array<B>, rest: Array<B>]
-  <A, B extends A>(
-    self: Iterable<A>,
+  <C extends A, B extends A, A = C>(
     refinement: Refinement<A, B>
-  ): [init: Array<B>, rest: Array<A>]
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): [init: Array<B>, rest: Array<B>]
+  ): (self: Iterable<C>) => [init: Array<B>, rest: Array<Exclude<C, B>>]
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => [init: Array<B>, rest: Array<B>]
+  <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): [init: Array<B>, rest: Array<Exclude<A, B>>]
+  <A>(self: Iterable<A>, predicate: Predicate<A>): [init: Array<A>, rest: Array<A>]
 } = dual(
   2,
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): [init: Array<B>, rest: Array<B>] =>
+  <A>(self: Iterable<A>, predicate: Predicate<A>): [init: Array<A>, rest: Array<A>] =>
     splitAt(self, spanIndex(self, predicate))
 )
 
@@ -651,14 +648,11 @@ export const dropRight: {
  * @since 2.0.0
  */
 export const dropWhile: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Array<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Array<B>
-  <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Array<B>
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Array<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Array<B>
+  <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A>
 } = dual(
   2,
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Array<B> =>
-    fromIterable(self).slice(spanIndex(self, predicate))
+  <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A> => fromIterable(self).slice(spanIndex(self, predicate))
 )
 
 /**
@@ -709,10 +703,10 @@ export const findLastIndex: {
  */
 export const findFirst: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Option<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Option<B>
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Option<B>
-} = dual(2, <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Option<B> => {
+  <A>(self: Iterable<A>, predicate: Predicate<A>): Option<A>
+} = dual(2, <A>(self: Iterable<A>, predicate: Predicate<A>): Option<A> => {
   const input = fromIterable(self)
   for (let i = 0; i < input.length; i++) {
     if (predicate(input[i])) {
@@ -730,10 +724,10 @@ export const findFirst: {
  */
 export const findLast: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Option<B>
-  <A>(predicate: Predicate<A>): <B extends A>(self: Iterable<B>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Option<B>
-  <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Option<B>
-} = dual(2, <B extends A, A>(self: Iterable<B>, predicate: Predicate<A>): Option<B> => {
+  <A>(self: Iterable<A>, predicate: Predicate<A>): Option<A>
+} = dual(2, <A>(self: Iterable<A>, predicate: Predicate<A>): Option<A> => {
   const input = fromIterable(self)
   for (let i = input.length - 1; i >= 0; i--) {
     if (predicate(input[i])) {
@@ -1252,8 +1246,8 @@ export const chopNonEmpty: {
  * @since 2.0.0
  */
 export const splitAt: {
-  (n: number): <A>(self: Iterable<A>) => [Array<A>, Array<A>]
-  <A>(self: Iterable<A>, n: number): [Array<A>, Array<A>]
+  (n: number): <A>(self: Iterable<A>) => [beforeIndex: Array<A>, fromIndex: Array<A>]
+  <A>(self: Iterable<A>, n: number): [beforeIndex: Array<A>, fromIndex: Array<A>]
 } = dual(2, <A>(self: Iterable<A>, n: number): [Array<A>, Array<A>] => {
   const input = Array.from(self)
   return n >= 1 && isNonEmptyReadonlyArray(input) ?
@@ -1278,8 +1272,8 @@ export const copy: {
  * @since 2.0.0
  */
 export const splitNonEmptyAt: {
-  (n: number): <A>(self: NonEmptyReadonlyArray<A>) => [NonEmptyArray<A>, Array<A>]
-  <A>(self: NonEmptyReadonlyArray<A>, n: number): [NonEmptyArray<A>, Array<A>]
+  (n: number): <A>(self: NonEmptyReadonlyArray<A>) => [beforeIndex: NonEmptyArray<A>, fromIndex: Array<A>]
+  <A>(self: NonEmptyReadonlyArray<A>, n: number): [beforeIndex: NonEmptyArray<A>, fromIndex: Array<A>]
 } = dual(2, <A>(self: NonEmptyReadonlyArray<A>, n: number): [NonEmptyArray<A>, Array<A>] => {
   const m = Math.max(1, n)
   return m >= self.length ?
@@ -1627,11 +1621,11 @@ export const filterMapWhile: {
  * @since 2.0.0
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A, i: number) => Either<B, C>): (self: Iterable<A>) => [Array<B>, Array<C>]
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [Array<B>, Array<C>]
+  <A, B, C>(f: (a: A, i: number) => Either<B, C>): (self: Iterable<A>) => [left: Array<B>, right: Array<C>]
+  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [left: Array<B>, right: Array<C>]
 } = dual(
   2,
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [Array<B>, Array<C>] => {
+  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [left: Array<B>, right: Array<C>] => {
     const left: Array<B> = []
     const right: Array<C> = []
     const as = fromIterable(self)
@@ -1658,15 +1652,10 @@ export const compact: <A>(self: Iterable<Option<A>>) => Array<A> = filterMap(ide
  * @since 2.0.0
  */
 export const filter: {
-  <C extends A, B extends A, A = C>(
-    refinement: (a: A, i: number) => a is B
-  ): (self: Iterable<C>) => Array<B>
-  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>
-  <C extends A, B extends A, A = C>(
-    self: Iterable<C>,
-    refinement: (a: A, i: number) => a is B
-  ): Array<B>
-  <B extends A, A = B>(self: Iterable<B>, predicate: (a: A, i: number) => boolean): Array<B>
+  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Array<B>
+  <A, B extends A>(predicate: (b: B, i: number) => boolean): (self: Iterable<A>) => Array<A>
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
 } = dual(
   2,
   <B extends A, A = B>(self: Iterable<B>, predicate: (a: A, i: number) => boolean): Array<B> => {
@@ -1682,32 +1671,28 @@ export const filter: {
 )
 
 /**
+ * Separate elements based on a predicate that also exposes the index of the element.
+ *
  * @category filtering
  * @since 2.0.0
  */
 export const partition: {
   <C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (
     self: Iterable<C>
-  ) => [Array<C>, Array<B>]
+  ) => [excluded: Array<Exclude<C, B>>, satisfying: Array<B>]
   <B extends A, A = B>(
     predicate: (a: A, i: number) => boolean
-  ): (self: Iterable<B>) => [Array<B>, Array<B>]
-  <C extends A, B extends A, A = C>(
-    self: Iterable<C>,
+  ): (self: Iterable<B>) => [excluded: Array<B>, satisfying: Array<B>]
+  <A, B extends A>(
+    self: Iterable<A>,
     refinement: (a: A, i: number) => a is B
-  ): [Array<C>, Array<B>]
-  <B extends A, A = B>(
-    self: Iterable<B>,
-    predicate: (a: A, i: number) => boolean
-  ): [Array<B>, Array<B>]
+  ): [excluded: Array<Exclude<A, B>>, satisfying: Array<B>]
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [excluded: Array<A>, satisfying: Array<A>]
 } = dual(
   2,
-  <B extends A, A = B>(
-    self: Iterable<B>,
-    predicate: (a: A, i: number) => boolean
-  ): [Array<B>, Array<B>] => {
-    const left: Array<B> = []
-    const right: Array<B> = []
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [excluded: Array<A>, satisfying: Array<A>] => {
+    const left: Array<A> = []
+    const right: Array<A> = []
     const as = fromIterable(self)
     for (let i = 0; i < as.length; i++) {
       if (predicate(as[i], i)) {
@@ -1759,9 +1744,9 @@ export const reduceRight: {
  * @since 2.0.0
  */
 export const liftPredicate: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (c: C) => Array<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Array<B>
-} = <B extends A, A = B>(predicate: Predicate<A>) => (b: B) => predicate(b) ? [b] : []
+  <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Array<B>
+  <A>(predicate: Predicate<A>): <B extends A>(b: B) => Array<B>
+} = <A>(predicate: Predicate<A>) => <B extends A>(b: B): Array<B> => predicate(b) ? [b] : []
 
 /**
  * @category lifting
@@ -1836,8 +1821,8 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <A>(predicate: Predicate<A>): <B extends A>(self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>
-  <B extends A, A = B>(self: ReadonlyArray<B>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>
+  <A>(self: ReadonlyArray<A>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<A>
 } = dual(
   2,
   <A>(self: ReadonlyArray<A>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<A> => self.some(predicate)
@@ -1983,9 +1968,9 @@ export const join: {
  * @category folding
  */
 export const mapAccum: {
-  <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Iterable<A>) => [S, Array<B>]
-  <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [S, Array<B>]
-} = dual(3, <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => [S, B]) => {
+  <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Iterable<A>) => [state: S, mappedArray: Array<B>]
+  <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [state: S, mappedArray: Array<B>]
+} = dual(3, <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => [S, B]): [state: S, mappedArray: Array<B>] => {
   let s1 = s
   const out: Array<B> = []
   for (const a of self) {

package/src/ReadonlyRecord.ts

@@ -16,7 +16,7 @@ import * as Option from "./Option.js"
  * @category models
  * @since 2.0.0
  */
-export interface ReadonlyRecord<A> {
+export interface ReadonlyRecord<out A> {
   readonly [x: string]: A
 }
 
@@ -436,27 +436,19 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filter: {
-  <K extends string, C extends A, B extends A, A = C>(
-    refinement: (a: A, key: K) => a is B
-  ): (self: Record<K, C>) => Record<string, B>
+  <K extends string, A, B extends A>(refinement: (a: A, key: K) => a is B): (self: Record<K, A>) => Record<string, B>
   <K extends string, B extends A, A = B>(
-    predicate: (a: A, key: K) => boolean
+    predicate: (A: A, key: K) => boolean
   ): (self: Record<K, B>) => Record<string, B>
-  <K extends string, C extends A, B extends A, A = C>(
-    self: Record<K, C>,
-    refinement: (a: A, key: K) => a is B
-  ): Record<string, B>
-  <K extends string, B extends A, A = B>(
-    self: Record<K, B>,
-    predicate: (a: A, key: K) => boolean
-  ): Record<string, B>
+  <K extends string, A, B extends A>(self: Record<K, A>, refinement: (a: A, key: K) => a is B): Record<string, B>
+  <K extends string, A>(self: Record<K, A>, predicate: (a: A, key: K) => boolean): Record<string, A>
 } = dual(
   2,
-  <B extends A, A = B>(
-    self: Record<string, B>,
+  <A>(
+    self: Record<string, A>,
     predicate: (a: A, key: string) => boolean
-  ): Record<string, B> => {
-    const out: Record<string, B> = {}
+  ): Record<string, A> => {
+    const out: Record<string, A> = {}
     for (const key of Object.keys(self)) {
       if (predicate(self[key], key)) {
         out[key] = self[key]
@@ -507,17 +499,17 @@ export const compact: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<stri
 export const partitionMap: {
   <K extends string, A, B, C>(
     f: (a: A, key: K) => Either<B, C>
-  ): (self: Record<K, A>) => [Record<string, B>, Record<string, C>]
+  ): (self: Record<K, A>) => [left: Record<string, B>, right: Record<string, C>]
   <K extends string, A, B, C>(
     self: Record<K, A>,
     f: (a: A, key: K) => Either<B, C>
-  ): [Record<string, B>, Record<string, C>]
+  ): [left: Record<string, B>, right: Record<string, C>]
 } = dual(
   2,
   <A, B, C>(
     self: Record<string, A>,
     f: (a: A, key: string) => Either<B, C>
-  ): [Record<string, B>, Record<string, C>] => {
+  ): [left: Record<string, B>, right: Record<string, C>] => {
     const left: Record<string, B> = {}
     const right: Record<string, C> = {}
     for (const key of Object.keys(self)) {
@@ -574,26 +566,26 @@ export const separate: <A, B>(
 export const partition: {
   <K extends string, C extends A, B extends A, A = C>(refinement: (a: A, key: K) => a is B): (
     self: Record<K, C>
-  ) => [Record<string, C>, Record<string, B>]
+  ) => [excluded: Record<string, Exclude<C, B>>, satisfying: Record<string, B>]
   <K extends string, B extends A, A = B>(
     predicate: (a: A, key: K) => boolean
-  ): (self: Record<K, B>) => [Record<string, B>, Record<string, B>]
-  <K extends string, C extends A, B extends A, A = C>(
-    self: Record<K, C>,
+  ): (self: Record<K, B>) => [excluded: Record<string, B>, satisfying: Record<string, B>]
+  <K extends string, A, B extends A>(
+    self: Record<K, A>,
     refinement: (a: A, key: K) => a is B
-  ): [Record<string, C>, Record<string, B>]
-  <K extends string, B extends A, A = B>(
-    self: Record<K, B>,
+  ): [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+  <K extends string, A>(
+    self: Record<K, A>,
     predicate: (a: A, key: K) => boolean
-  ): [Record<string, B>, Record<string, B>]
+  ): [excluded: Record<string, A>, satisfying: Record<string, A>]
 } = dual(
   2,
-  <B extends A, A = B>(
-    self: Record<string, B>,
+  <A>(
+    self: Record<string, A>,
     predicate: (a: A, key: string) => boolean
-  ): [Record<string, B>, Record<string, B>] => {
-    const left: Record<string, B> = {}
-    const right: Record<string, B> = {}
+  ): [excluded: Record<string, A>, satisfying: Record<string, A>] => {
+    const left: Record<string, A> = {}
+    const right: Record<string, A> = {}
     for (const key of Object.keys(self)) {
       if (predicate(self[key], key)) {
         right[key] = self[key]
@@ -740,11 +732,21 @@ export const reduce: {
  * @since 2.0.0
  */
 export const every: {
+  <A, K extends string, B extends A>(
+    refinement: (value: A, key: K) => value is B
+  ): (self: Record<K, A>) => self is Readonly<Record<K, B>>
   <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: Record<K, A>) => boolean
+  <A, K extends string, B extends A>(
+    self: Record<K, A>,
+    refinement: (value: A, key: K) => value is B
+  ): self is Readonly<Record<K, B>>
   <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean
-} = dual(2, <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean => {
+} = dual(2, <A, K extends string, B extends A>(
+  self: Record<K, A>,
+  refinement: (value: A, key: K) => value is B
+): self is Readonly<Record<K, A>> => {
   for (const key in self) {
-    if (!predicate(self[key], key)) {
+    if (!refinement(self[key], key)) {
       return false
     }
   }