effect 3.2.4 → 3.2.6

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.2.4";
+let moduleVersion = "3.2.6";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.2.4",
+  "version": "3.2.6",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Array.ts

@@ -326,7 +326,7 @@ export const prepend: {
  * @since 2.0.0
  */
 export const prependAll: {
-  <S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>>(
+  <S extends Iterable<any>, T extends Iterable<any>>(
     that: T
   ): (self: S) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(self: Iterable<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<A | B>
@@ -363,7 +363,7 @@ export const append: {
  * @since 2.0.0
  */
 export const appendAll: {
-  <S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>>(
+  <S extends Iterable<any>, T extends Iterable<any>>(
     that: T
   ): (self: S) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(self: Iterable<A>, that: NonEmptyReadonlyArray<B>): NonEmptyArray<A | B>
@@ -1365,7 +1365,7 @@ export const unzip: <S extends Iterable<readonly [any, any]> | NonEmptyReadonlyA
 export const intersperse: {
   <B>(
     middle: B
-  ): <S extends ReadonlyArray<any> | Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
+  ): <S extends Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
   <A, B>(self: NonEmptyReadonlyArray<A>, middle: B): NonEmptyArray<A | B>
   <A, B>(self: Iterable<A>, middle: B): Array<A | B>
 } = dual(2, <A, B>(self: Iterable<A>, middle: B): Array<A | B> => {
@@ -1478,7 +1478,7 @@ export const setNonEmptyLast: {
  * @since 2.0.0
  */
 export const rotate: {
-  (n: number): <S extends ReadonlyArray<any> | Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
+  (n: number): <S extends Iterable<any>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A>(self: NonEmptyReadonlyArray<A>, n: number): NonEmptyArray<A>
   <A>(self: Iterable<A>, n: number): Array<A>
 } = dual(2, <A>(self: Iterable<A>, n: number): Array<A> => {
@@ -1567,7 +1567,7 @@ export const contains: {
  * @since 2.0.0
  */
 export const chop: {
-  <S extends ReadonlyArray<any> | Iterable<any>, B>(
+  <S extends Iterable<any>, B>(
     f: (as: NonEmptyReadonlyArray<ReadonlyArray.Infer<S>>) => readonly [B, ReadonlyArray<ReadonlyArray.Infer<S>>]
   ): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A, B>(
@@ -1742,7 +1742,7 @@ export const copy: {
 export const chunksOf: {
   (
     n: number
-  ): <S extends ReadonlyArray<any> | Iterable<any>>(
+  ): <S extends Iterable<any>>(
     self: S
   ) => ReadonlyArray.With<S, NonEmptyArray<ReadonlyArray.Infer<S>>>
   <A>(self: NonEmptyReadonlyArray<A>, n: number): NonEmptyArray<NonEmptyArray<A>>
@@ -1864,7 +1864,7 @@ export const groupBy: {
  * @since 2.0.0
  */
 export const unionWith: {
-  <S extends ReadonlyArray<any> | Iterable<any>, T extends ReadonlyArray<any> | Iterable<any>>(
+  <S extends Iterable<any>, T extends Iterable<any>>(
     that: T,
     isEquivalent: (self: ReadonlyArray.Infer<S>, that: ReadonlyArray.Infer<T>) => boolean
   ): (self: S) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
@@ -1906,9 +1906,9 @@ export const unionWith: {
  * @since 2.0.0
  */
 export const union: {
-  <T extends ReadonlyArray<any> | Iterable<any>>(
+  <T extends Iterable<any>>(
     that: T
-  ): <S extends ReadonlyArray<any> | Iterable<any>>(
+  ): <S extends Iterable<any>>(
     self: S
   ) => ReadonlyArray.OrNonEmpty<S, T, ReadonlyArray.Infer<S> | ReadonlyArray.Infer<T>>
   <A, B>(self: NonEmptyReadonlyArray<A>, that: ReadonlyArray<B>): NonEmptyArray<A | B>
@@ -2026,23 +2026,22 @@ export declare namespace ReadonlyArray {
   /**
    * @since 2.0.0
    */
-  export type Infer<S extends ReadonlyArray<any> | Iterable<any>> = S extends ReadonlyArray<infer A> ? A
+  export type Infer<S extends Iterable<any>> = S extends ReadonlyArray<infer A> ? A
     : S extends Iterable<infer A> ? A
     : never
 
   /**
    * @since 2.0.0
    */
-  export type With<S extends ReadonlyArray<any> | Iterable<any>, A> = S extends NonEmptyReadonlyArray<any> ?
-    NonEmptyArray<A>
+  export type With<S extends Iterable<any>, A> = S extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
     : Array<A>
 
   /**
    * @since 2.0.0
    */
   export type OrNonEmpty<
-    S extends ReadonlyArray<any> | Iterable<any>,
-    T extends ReadonlyArray<any> | Iterable<any>,
+    S extends Iterable<any>,
+    T extends Iterable<any>,
     A
   > = S extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
     : T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
@@ -2052,8 +2051,8 @@ export declare namespace ReadonlyArray {
    * @since 2.0.0
    */
   export type AndNonEmpty<
-    S extends ReadonlyArray<any> | Iterable<any>,
-    T extends ReadonlyArray<any> | Iterable<any>,
+    S extends Iterable<any>,
+    T extends Iterable<any>,
     A
   > = S extends NonEmptyReadonlyArray<any> ? T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
     : Array<A>
@@ -2255,7 +2254,10 @@ export const partitionMap: {
  * @category filtering
  * @since 2.0.0
  */
-export const getSomes: <A>(self: Iterable<Option<A>>) => Array<A> = filterMap(identity)
+
+export const getSomes: <T extends Iterable<Option<X>>, X = any>(
+  self: T
+) => Array<Option.Value<ReadonlyArray.Infer<T>>> = filterMap(identity as any)
 
 /**
  * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
@@ -2271,8 +2273,8 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Array<A> = filterMap(id
  * @category filtering
  * @since 2.0.0
  */
-export const getLefts = <R, L>(self: Iterable<Either<R, L>>): Array<L> => {
-  const out: Array<L> = []
+export const getLefts = <T extends Iterable<Either<any, any>>>(self: T): Array<Either.Left<ReadonlyArray.Infer<T>>> => {
+  const out: Array<any> = []
   for (const a of self) {
     if (E.isLeft(a)) {
       out.push(a.left)
@@ -2296,8 +2298,10 @@ export const getLefts = <R, L>(self: Iterable<Either<R, L>>): Array<L> => {
  * @category filtering
  * @since 2.0.0
  */
-export const getRights = <R, L>(self: Iterable<Either<R, L>>): Array<R> => {
-  const out: Array<R> = []
+export const getRights = <T extends Iterable<Either<any, any>>>(
+  self: T
+): Array<Either.Right<ReadonlyArray.Infer<T>>> => {
+  const out: Array<any> = []
   for (const a of self) {
     if (E.isRight(a)) {
       out.push(a.right)
@@ -2378,7 +2382,9 @@ export const partition: {
  * @category filtering
  * @since 2.0.0
  */
-export const separate: <R, L>(self: Iterable<Either<R, L>>) => [Array<L>, Array<R>] = partitionMap(
+export const separate: <T extends Iterable<Either<any, any>>>(
+  self: T
+) => [Array<Either.Left<ReadonlyArray.Infer<T>>>, Array<Either.Right<ReadonlyArray.Infer<T>>>] = partitionMap(
   identity
 )
 
@@ -2700,7 +2706,7 @@ export const forEach: {
  * @since 2.0.0
  */
 export const dedupeWith: {
-  <S extends ReadonlyArray<any> | Iterable<any>>(
+  <S extends Iterable<any>>(
     isEquivalent: (self: ReadonlyArray.Infer<S>, that: ReadonlyArray.Infer<S>) => boolean
   ): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
   <A>(self: NonEmptyReadonlyArray<A>, isEquivalent: (self: A, that: A) => boolean): NonEmptyArray<A>

package/src/RequestResolver.ts

@@ -27,33 +27,32 @@ export const RequestResolverTypeId: unique symbol = core.RequestResolverTypeId
 export type RequestResolverTypeId = typeof RequestResolverTypeId
 
 /**
- * A `RequestResolver<A, R>` requires an environment `R` and is capable of executing
- * requests of type `A`.
+ * The `RequestResolver<A, R>` interface requires an environment `R` and handles
+ * the execution of requests of type `A`.
  *
- * Data sources must implement the method `runAll` which takes a collection of
- * requests and returns an effect with a `RequestCompletionMap` containing a
- * mapping from requests to results. The type of the collection of requests is
- * a `Chunk<Chunk<A>>`. The outer `Chunk` represents batches of requests that
- * must be performed sequentially. The inner `Chunk` represents a batch of
- * requests that can be performed in parallel. This allows data sources to
- * introspect on all the requests being executed and optimize the query.
+ * Implementations must provide a `runAll` method, which processes a collection
+ * of requests and produces an effect that fulfills these requests. Requests are
+ * organized into a `Array<Array<A>>`, where the outer `Array` groups requests
+ * into batches that are executed sequentially, and each inner `Array` contains
+ * requests that can be executed in parallel. This structure allows
+ * implementations to analyze all incoming requests collectively and optimize
+ * query execution accordingly.
  *
- * Data sources will typically be parameterized on a subtype of `Request<A>`,
- * though that is not strictly necessarily as long as the data source can map
- * the request type to a `Request<A>`. Data sources can then pattern match on
- * the collection of requests to determine the information requested, execute
- * the query, and place the results into the `RequestCompletionMap` using
- * `RequestCompletionMap.empty` and `RequestCompletionMap.insert`. Data
- * sources must provide results for all requests received. Failure to do so
- * will cause a query to die with a `QueryFailure` when run.
+ * Implementations are typically specialized for a subtype of `Request<A, E>`.
+ * However, they are not strictly limited to these subtypes as long as they can
+ * map any given request type to `Request<A, E>`. Implementations should inspect
+ * the collection of requests to identify the needed information and execute the
+ * corresponding queries. It is imperative that implementations resolve all the
+ * requests they receive. Failing to do so will lead to a `QueryFailure` error
+ * during query execution.
  *
  * @since 2.0.0
  * @category models
  */
 export interface RequestResolver<in A, out R = never> extends RequestResolver.Variance<A, R>, Equal.Equal, Pipeable {
   /**
-   * Execute a collection of requests. The outer `Chunk` represents batches
-   * of requests that must be performed sequentially. The inner `Chunk`
+   * Execute a collection of requests. The outer `Array` represents batches
+   * of requests that must be performed sequentially. The inner `Array`
    * represents a batch of requests that can be performed in parallel.
    */
   runAll(requests: Array<Array<Request.Entry<A>>>): Effect.Effect<void, never, R>
@@ -132,8 +131,7 @@ export const makeWithEntry: <A, R>(
 ) => RequestResolver<A, R> = internal.makeWithEntry
 
 /**
- * Constructs a data source from a function taking a collection of requests
- * and returning a `RequestCompletionMap`.
+ * Constructs a data source from a function taking a collection of requests.
  *
  * @since 2.0.0
  * @category constructors

package/src/Types.ts

@@ -187,7 +187,6 @@ export type Mutable<T> = {
  */
 export type DeepMutable<T> = T extends ReadonlyMap<infer K, infer V> ? Map<DeepMutable<K>, DeepMutable<V>>
   : T extends ReadonlySet<infer V> ? Set<DeepMutable<V>>
-  : T extends ReadonlyArray<infer V> ? Array<DeepMutable<V>>
   : [keyof T] extends [never] ? T
   : { -readonly [K in keyof T]: DeepMutable<T[K]> }
 

package/src/internal/core.ts

@@ -1781,7 +1781,6 @@ export class RequestResolverImpl<in A, out R> implements RequestResolver.Request
     ) => Effect.Effect<void, never, R>,
     readonly target?: unknown
   ) {
-    this.runAll = runAll as any
   }
   [Hash.symbol](): number {
     return Hash.cached(this, this.target ? Hash.hash(this.target) : Hash.random(this))

package/src/internal/stream.ts

@@ -6555,7 +6555,7 @@ export const toReadableStreamRuntime = dual<
   <A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>) => ReadableStream<A>
 >(2, <A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>): ReadableStream<A> => {
   const runSync = Runtime.runSync(runtime)
-  const runPromise = Runtime.runPromise(runtime)
+  const runFork = Runtime.runFork(runtime)
 
   let pull: Effect.Effect<void, never, R>
   let scope: Scope.CloseableScope
@@ -6588,10 +6588,14 @@ export const toReadableStreamRuntime = dual<
       )
     },
     pull() {
-      return runPromise(pull)
+      return new Promise<void>((resolve) => {
+        runFork(pull, { scope }).addObserver((_) => resolve())
+      })
     },
     cancel() {
-      return runPromise(Scope.close(scope, Exit.void))
+      return new Promise<void>((resolve) => {
+        runFork(Scope.close(scope, Exit.void)).addObserver((_) => resolve())
+      })
     }
   })
 })

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.2.4"
+let moduleVersion = "3.2.6"
 
 export const getCurrentVersion = () => moduleVersion