effect 2.0.0-next.56 → 2.0.0-next.57

package/src/ReadonlyRecord.ts

@@ -370,6 +370,7 @@ export const pop: {
  *
  * assert.deepStrictEqual(map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" })
  *
+ * @category mapping
  * @since 2.0.0
  */
 export const map: {
@@ -459,26 +460,80 @@ export const filter: {
 )
 
 /**
- * Given a record with `Option` values, returns a record with only the `Some` values, with the same keys.
+ * Given a record with `Option` values, returns a new record containing only the `Some` values, preserving the original keys.
  *
  * @param self - A record with `Option` values.
  *
  * @example
- * import { compact } from "effect/ReadonlyRecord"
- * import { some, none } from 'effect/Option'
+ * import { getSomes } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
- *   compact({ a: some(1), b: none(), c: some(2) }),
+ *   getSomes({ a: some(1), b: none(), c: some(2) }),
  *   { a: 1, c: 2 }
  * )
  *
  * @category filtering
  * @since 2.0.0
  */
-export const compact: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
+export const getSomes: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
   identity
 )
 
+/**
+ * Given a record with `Either` values, returns a new record containing only the `Left` values, preserving the original keys.
+ *
+ * @example
+ * import { getLefts } from "effect/ReadonlyRecord"
+ * import { right, left } from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   getLefts({ a: right(1), b: left("err"), c: right(2) }),
+ *   { b: "err" }
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getLefts = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<string, E> => {
+  const out: Record<string, E> = {}
+  for (const key of Object.keys(self)) {
+    const value = self[key]
+    if (E.isLeft(value)) {
+      out[key] = value.left
+    }
+  }
+
+  return out
+}
+
+/**
+ * Given a record with `Either` values, returns a new record containing only the `Right` values, preserving the original keys.
+ *
+ * @example
+ * import { getRights } from "effect/ReadonlyRecord"
+ * import { right, left } from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   getRights({ a: right(1), b: left("err"), c: right(2) }),
+ *   { a: 1, c: 2 }
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getRights = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<string, A> => {
+  const out: Record<string, A> = {}
+  for (const key of Object.keys(self)) {
+    const value = self[key]
+    if (E.isRight(value)) {
+      out[key] = value.right
+    }
+  }
+
+  return out
+}
+
 /**
  * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
  *

package/src/RedBlackTree.ts

@@ -9,6 +9,7 @@ import * as RBTI from "./internal/redBlackTree/iterator.js"
 import type { Option } from "./Option.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 const TypeId: unique symbol = RBT.RedBlackTreeTypeId as TypeId
 
@@ -32,8 +33,8 @@ export const Direction = RBTI.Direction
  */
 export interface RedBlackTree<in out Key, out Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _Key: (_: Key) => Key
-    readonly _Value: (_: never) => Value
+    readonly _Key: Types.Invariant<Key>
+    readonly _Value: Types.Covariant<Value>
   }
 }
 

package/src/Ref.ts

@@ -5,6 +5,7 @@ import type * as Effect from "./Effect.js"
 import * as internal from "./internal/ref.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -36,7 +37,7 @@ export declare namespace Ref {
    */
   export interface Variance<in out A> {
     readonly [RefTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Reloadable.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/reloadable.js"
 import type * as Layer from "./Layer.js"
 import type * as Schedule from "./Schedule.js"
 import type * as ScopedRef from "./ScopedRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -48,7 +49,7 @@ export declare namespace Reloadable {
    */
   export interface Variance<in out A> {
     readonly [ReloadableTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Request.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import type * as _Cache from "./Cache.js"
+import type { Cause } from "./Cause.js"
 import type * as Data from "./Data.js"
 import type { Deferred } from "./Deferred.js"
 import type { DurationInput } from "./Duration.js"
@@ -47,8 +48,8 @@ export declare namespace Request {
    */
   export interface Variance<out E, out A> {
     readonly [RequestTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 
@@ -216,6 +217,17 @@ export const fail: {
   <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<never, never, void>
 } = internal.fail
 
+/**
+ * Complete a `Request` with the specified cause.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const failCause: {
+  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<never, never, void>
+  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<never, never, void>
+} = internal.failCause
+
 /**
  * Complete a `Request` with the specified value.
  *
@@ -312,7 +324,7 @@ export declare namespace Entry {
    */
   export interface Variance<out R> {
     readonly [EntryTypeId]: {
-      readonly _R: (_: never) => R
+      readonly _R: Types.Covariant<R>
     }
   }
 }

package/src/RequestBlock.ts

@@ -1,11 +1,7 @@
 /**
  * @since 2.0.0
  */
-import type * as Context from "./Context.js"
-import type { FiberRef } from "./FiberRef.js"
 import * as _RequestBlock from "./internal/blockedRequests.js"
-import * as core from "./internal/core.js"
-import * as _dataSource from "./internal/dataSource.js"
 import type * as Request from "./Request.js"
 import type * as RequestResolver from "./RequestResolver.js"
 
@@ -19,7 +15,7 @@ import type * as RequestResolver from "./RequestResolver.js"
  * @since 2.0.0
  * @category models
  */
-export type RequestBlock<R> = Empty | Par<R> | Seq<R> | Single<R>
+export type RequestBlock = Empty | Par | Seq | Single
 
 /**
  * @since 2.0.0
@@ -30,11 +26,11 @@ export declare namespace RequestBlock {
    * @since 2.0.0
    * @category models
    */
-  export interface Reducer<in R, in out Z> {
+  export interface Reducer<in out Z> {
     emptyCase(): Z
     parCase(left: Z, right: Z): Z
     singleCase(
-      dataSource: RequestResolver.RequestResolver<unknown, R>,
+      dataSource: RequestResolver.RequestResolver<unknown, never>,
       blockedRequest: Request.Entry<unknown>
     ): Z
     seqCase(left: Z, right: Z): Z
@@ -53,29 +49,29 @@ export interface Empty {
  * @since 2.0.0
  * @category models
  */
-export interface Par<out R> {
+export interface Par {
   readonly _tag: "Par"
-  readonly left: RequestBlock<R>
-  readonly right: RequestBlock<R>
+  readonly left: RequestBlock
+  readonly right: RequestBlock
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Seq<out R> {
+export interface Seq {
   readonly _tag: "Seq"
-  readonly left: RequestBlock<R>
-  readonly right: RequestBlock<R>
+  readonly left: RequestBlock
+  readonly right: RequestBlock
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Single<out R> {
+export interface Single {
   readonly _tag: "Single"
-  readonly dataSource: RequestResolver.RequestResolver<unknown, R>
+  readonly dataSource: RequestResolver.RequestResolver<unknown, never>
   readonly blockedRequest: Request.Entry<unknown>
 }
 
@@ -83,75 +79,40 @@ export interface Single<out R> {
  * @since 2.0.0
  * @category constructors
  */
-export const single: <R, A>(
-  dataSource: RequestResolver.RequestResolver<A, R>,
+export const single: <A>(
+  dataSource: RequestResolver.RequestResolver<A, never>,
   blockedRequest: Request.Entry<A>
-) => RequestBlock<R> = _RequestBlock.single
+) => RequestBlock = _RequestBlock.single
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const empty: RequestBlock<never> = _RequestBlock.empty
+export const empty: RequestBlock = _RequestBlock.empty
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const mapRequestResolvers: <R, A, R2>(
-  self: RequestBlock<R>,
-  f: (dataSource: RequestResolver.RequestResolver<A, R>) => RequestResolver.RequestResolver<A, R2>
-) => RequestBlock<R | R2> = _RequestBlock.mapRequestResolvers
+export const mapRequestResolvers: <A>(
+  self: RequestBlock,
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+) => RequestBlock = _RequestBlock.mapRequestResolvers
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const parallel: <R, R2>(self: RequestBlock<R>, that: RequestBlock<R2>) => RequestBlock<R | R2> =
-  _RequestBlock.par
+export const parallel: (self: RequestBlock, that: RequestBlock) => RequestBlock = _RequestBlock.par
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const reduce: <R, Z>(self: RequestBlock<R>, reducer: RequestBlock.Reducer<R, Z>) => Z = _RequestBlock.reduce
+export const reduce: <Z>(self: RequestBlock, reducer: RequestBlock.Reducer<Z>) => Z = _RequestBlock.reduce
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const sequential: <R, R2>(self: RequestBlock<R>, that: RequestBlock<R2>) => RequestBlock<R | R2> =
-  _RequestBlock.seq
-
-/**
- * Provides each data source with part of its required environment.
- *
- * @since 2.0.0
- * @category utils
- */
-export const mapInputContext = <R0, R>(
-  self: RequestBlock<R>,
-  f: (context: Context.Context<R0>) => Context.Context<R>
-): RequestBlock<R0> => reduce(self, MapInputContextReducer(f))
-
-const MapInputContextReducer = <R0, R>(
-  f: (context: Context.Context<R0>) => Context.Context<R>
-): RequestBlock.Reducer<R, RequestBlock<R0>> => ({
-  emptyCase: () => empty,
-  parCase: (left, right) => parallel(left, right),
-  seqCase: (left, right) => sequential(left, right),
-  singleCase: (dataSource, blockedRequest) =>
-    single(
-      _dataSource.mapInputContext(dataSource, f),
-      blockedRequest as any
-    )
-})
-
-/**
- * Provides each data source with a fiber ref value.
- *
- * @since 2.0.0
- * @category utils
- */
-export const locally: <R, A>(self: RequestBlock<R>, ref: FiberRef<A>, value: A) => RequestBlock<R> =
-  core.requestBlockLocally
+export const sequential: (self: RequestBlock, that: RequestBlock) => RequestBlock = _RequestBlock.seq

package/src/RequestResolver.ts

@@ -11,6 +11,7 @@ import * as core from "./internal/core.js"
 import * as internal from "./internal/dataSource.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Request from "./Request.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -72,8 +73,8 @@ export declare namespace RequestResolver {
    */
   export interface Variance<in A, out R> {
     readonly [RequestResolverTypeId]: {
-      readonly _A: (_: A) => void
-      readonly _R: (_: never) => R
+      readonly _A: Types.Contravariant<A>
+      readonly _R: Types.Covariant<R>
     }
   }
 }

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
@@ -44,8 +45,8 @@ export declare namespace Resource {
    */
   export interface Variance<in out E, in out A> {
     readonly [ResourceTypeId]: {
-      _E: (_: E) => E
-      _A: (_: A) => A
+      _E: Types.Invariant<E>
+      _A: Types.Invariant<A>
     }
   }
 }

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"
 
 /**
@@ -139,9 +140,9 @@ export declare namespace STM {
    */
   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>
     }
   }
 }

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
@@ -92,9 +93,9 @@ export declare namespace Schedule {
    */
   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>
     }
   }
 
@@ -103,9 +104,9 @@ export declare namespace Schedule {
    */
   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>
     }
   }
 }

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
@@ -99,9 +100,9 @@ export declare namespace ScopedCache {
    */
   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
@@ -45,7 +46,7 @@ export declare namespace ScopedRef {
    */
   export interface Variance<in out A> {
     readonly [ScopedRefTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<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"
 
 /**
@@ -98,11 +99,11 @@ export declare namespace Sink {
    * @category models
    */
   export interface VarianceStruct<out R, out E, in In, out L, out Z> {
-    _R: (_: never) => R
-    _E: (_: never) => E
-    _In: (_: In) => void
-    _L: (_: never) => L
-    _Z: (_: never) => Z
+    _R: Types.Covariant<R>
+    _E: Types.Covariant<E>
+    _In: Types.Contravariant<In>
+    _L: Types.Covariant<L>
+    _Z: Types.Covariant<Z>
   }
 }
 

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")
 
@@ -27,8 +28,8 @@ export type TypeId = typeof TypeId
  */
 export interface SortedMap<in out K, out V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _K: (_: K) => K
-    readonly _V: (_: never) => V
+    readonly _K: Types.Invariant<K>
+    readonly _V: Types.Covariant<V>
   }
   /** @internal */
   readonly tree: RBT.RedBlackTree<K, V>
@@ -49,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 {

package/src/SortedSet.ts

@@ -6,13 +6,14 @@ import * as Dual from "./Function.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { Inspectable } from "./Inspectable.js"
-import { NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.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/SortedSet")
 
@@ -28,7 +29,7 @@ export type TypeId = typeof TypeId
  */
 export interface SortedSet<in out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _A: (_: A) => A
+    readonly _A: Types.Invariant<A>
   }
   /** @internal */
   readonly keyTree: RBT.RedBlackTree<A, boolean>
@@ -48,7 +49,7 @@ const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
     return RBT.keys(this.keyTree)
   },
   toString<A>(this: SortedSet<A>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {

package/src/Stream.ts

@@ -29,6 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -114,9 +115,9 @@ export declare namespace Stream {
    */
   export interface Variance<out R, out E, out A> {
     readonly [StreamTypeId]: {
-      _R: (_: never) => R
-      _E: (_: never) => E
-      _A: (_: never) => A
+      _R: Types.Covariant<R>
+      _E: Types.Covariant<E>
+      _A: Types.Covariant<A>
     }
   }
 
@@ -320,7 +321,7 @@ export const asyncOption: <R, E, A>(
  * @category constructors
  */
 export const asyncScoped: <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>,
+  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R | Scope.Scope, E, unknown>,
   outputBuffer?: number
 ) => Stream<Exclude<R, Scope.Scope>, E, A> = internal.asyncScoped
 

package/src/Streamable.ts

@@ -6,8 +6,11 @@ import { pipeArguments } from "./Pipeable.js"
 import * as Stream from "./Stream.js"
 
 const streamVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 

package/src/SubscriptionRef.ts

@@ -9,6 +9,7 @@ import type * as PubSub from "./PubSub.js"
 import * as Ref from "./Ref.js"
 import type * as Stream from "./Stream.js"
 import * as Synchronized from "./SynchronizedRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -55,7 +56,7 @@ export declare namespace SubscriptionRef {
    */
   export interface Variance<in out A> {
     readonly [SubscriptionRefTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Supervisor.ts

@@ -15,6 +15,7 @@ import type * as Layer from "./Layer.js"
 import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
 import type * as SortedSet from "./SortedSet.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -94,7 +95,7 @@ export declare namespace Supervisor {
    */
   export interface Variance<out T> {
     readonly [SupervisorTypeId]: {
-      readonly _T: (_: never) => T
+      readonly _T: Types.Covariant<T>
     }
   }
 }