effect 3.10.18 → 3.11.0

package/src/Tuple.ts

@@ -23,9 +23,11 @@ export interface TupleTypeLambda extends TypeLambda {
  * @param elements - The list of elements to create the tuple from.
  *
  * @example
+ * ```ts
  * import { make } from "effect/Tuple"
  *
  * assert.deepStrictEqual(make(1, 'hello', true), [1, 'hello', true])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -38,9 +40,11 @@ export const make = <A extends ReadonlyArray<any>>(...elements: A): A => element
  * @param self - A tuple of length `2`.
  *
  * @example
+ * ```ts
  * import { getFirst } from "effect/Tuple"
  *
  * assert.deepStrictEqual(getFirst(["hello", 42]), "hello")
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -53,9 +57,11 @@ export const getFirst = <L, R>(self: readonly [L, R]): L => self[0]
  * @param self - A tuple of length `2`.
  *
  * @example
+ * ```ts
  * import { getSecond } from "effect/Tuple"
  *
  * assert.deepStrictEqual(getSecond(["hello", 42]), 42)
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -69,6 +75,7 @@ export const getSecond = <L, R>(self: readonly [L, R]): R => self[1]
  * @param f - The function to transform elements of the tuple.
  *
  * @example
+ * ```ts
  * import { pipe, Tuple } from "effect"
  *
  * const result = pipe(
@@ -76,6 +83,7 @@ export const getSecond = <L, R>(self: readonly [L, R]): R => self[1]
  *   Tuple.map((el) => el.toString().toUpperCase())
  * )
  * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+ * ```
  *
  * @category mapping
  * @since 3.9.0
@@ -88,6 +96,7 @@ export const map: {
    * @param f - The function to transform elements of the tuple.
    *
    * @example
+   * ```ts
    * import { pipe, Tuple } from "effect"
    *
    * const result = pipe(
@@ -95,6 +104,7 @@ export const map: {
    *   Tuple.map((el) => el.toString().toUpperCase())
    * )
    * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+   * ```
    *
    * @category mapping
    * @since 3.9.0
@@ -107,6 +117,7 @@ export const map: {
    * @param f - The function to transform elements of the tuple.
    *
    * @example
+   * ```ts
    * import { pipe, Tuple } from "effect"
    *
    * const result = pipe(
@@ -114,6 +125,7 @@ export const map: {
    *   Tuple.map((el) => el.toString().toUpperCase())
    * )
    * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+   * ```
    *
    * @category mapping
    * @since 3.9.0
@@ -135,12 +147,14 @@ export const map: {
  * @param g - The function to transform the second element of the tuple.
  *
  * @example
+ * ```ts
  * import { mapBoth } from "effect/Tuple"
  *
  * assert.deepStrictEqual(
  *   mapBoth(["hello", 42], { onFirst: s => s.toUpperCase(), onSecond: n => n.toString() }),
  *   ["HELLO", "42"]
  * )
+ * ```
  *
  * @category mapping
  * @since 2.0.0
@@ -154,12 +168,14 @@ export const mapBoth: {
    * @param g - The function to transform the second element of the tuple.
    *
    * @example
+   * ```ts
    * import { mapBoth } from "effect/Tuple"
    *
    * assert.deepStrictEqual(
    *   mapBoth(["hello", 42], { onFirst: s => s.toUpperCase(), onSecond: n => n.toString() }),
    *   ["HELLO", "42"]
    * )
+   * ```
    *
    * @category mapping
    * @since 2.0.0
@@ -178,12 +194,14 @@ export const mapBoth: {
    * @param g - The function to transform the second element of the tuple.
    *
    * @example
+   * ```ts
    * import { mapBoth } from "effect/Tuple"
    *
    * assert.deepStrictEqual(
    *   mapBoth(["hello", 42], { onFirst: s => s.toUpperCase(), onSecond: n => n.toString() }),
    *   ["HELLO", "42"]
    * )
+   * ```
    *
    * @category mapping
    * @since 2.0.0
@@ -213,12 +231,14 @@ export const mapBoth: {
  * @param f - The function to transform the first element of the tuple.
  *
  * @example
+ * ```ts
  * import { mapFirst } from "effect/Tuple"
  *
  * assert.deepStrictEqual(
  *   mapFirst(["hello", 42], s => s.toUpperCase()),
  *   ["HELLO", 42]
  * )
+ * ```
  *
  * @category mapping
  * @since 2.0.0
@@ -231,12 +251,14 @@ export const mapFirst: {
    * @param f - The function to transform the first element of the tuple.
    *
    * @example
+   * ```ts
    * import { mapFirst } from "effect/Tuple"
    *
    * assert.deepStrictEqual(
    *   mapFirst(["hello", 42], s => s.toUpperCase()),
    *   ["HELLO", 42]
    * )
+   * ```
    *
    * @category mapping
    * @since 2.0.0
@@ -249,12 +271,14 @@ export const mapFirst: {
    * @param f - The function to transform the first element of the tuple.
    *
    * @example
+   * ```ts
    * import { mapFirst } from "effect/Tuple"
    *
    * assert.deepStrictEqual(
    *   mapFirst(["hello", 42], s => s.toUpperCase()),
    *   ["HELLO", 42]
    * )
+   * ```
    *
    * @category mapping
    * @since 2.0.0
@@ -269,12 +293,14 @@ export const mapFirst: {
  * @param f - The function to transform the second element of the tuple.
  *
  * @example
+ * ```ts
  * import { mapSecond } from "effect/Tuple"
  *
  * assert.deepStrictEqual(
  *   mapSecond(["hello", 42], n => n.toString()),
  *   ["hello", "42"]
  * )
+ * ```
  *
  * @category mapping
  * @since 2.0.0
@@ -287,12 +313,14 @@ export const mapSecond: {
    * @param f - The function to transform the second element of the tuple.
    *
    * @example
+   * ```ts
    * import { mapSecond } from "effect/Tuple"
    *
    * assert.deepStrictEqual(
    *   mapSecond(["hello", 42], n => n.toString()),
    *   ["hello", "42"]
    * )
+   * ```
    *
    * @category mapping
    * @since 2.0.0
@@ -305,12 +333,14 @@ export const mapSecond: {
    * @param f - The function to transform the second element of the tuple.
    *
    * @example
+   * ```ts
    * import { mapSecond } from "effect/Tuple"
    *
    * assert.deepStrictEqual(
    *   mapSecond(["hello", 42], n => n.toString()),
    *   ["hello", "42"]
    * )
+   * ```
    *
    * @category mapping
    * @since 2.0.0
@@ -324,9 +354,11 @@ export const mapSecond: {
  * @param self - A tuple of length `2`.
  *
  * @example
+ * ```ts
  * import { swap } from "effect/Tuple"
  *
  * assert.deepStrictEqual(swap(["hello", 42]), [42, "hello"])
+ * ```
  *
  * @since 2.0.0
  */
@@ -388,9 +420,11 @@ export const appendElement: {
  * @param index - The index of the element to retrieve.
  *
  * @example
+ * ```ts
  * import { Tuple } from "effect"
  *
  * assert.deepStrictEqual(Tuple.at([1, 'hello', true], 1), 'hello')
+ * ```
  *
  * @category getters
  * @since 3.4.0
@@ -403,9 +437,11 @@ export const at: {
    * @param index - The index of the element to retrieve.
    *
    * @example
+   * ```ts
    * import { Tuple } from "effect"
    *
    * assert.deepStrictEqual(Tuple.at([1, 'hello', true], 1), 'hello')
+   * ```
    *
    * @category getters
    * @since 3.4.0
@@ -418,9 +454,11 @@ export const at: {
    * @param index - The index of the element to retrieve.
    *
    * @example
+   * ```ts
    * import { Tuple } from "effect"
    *
    * assert.deepStrictEqual(Tuple.at([1, 'hello', true], 1), 'hello')
+   * ```
    *
    * @category getters
    * @since 3.4.0
@@ -438,6 +476,7 @@ export {
    * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
    *
    * @example
+   * ```ts
    * import { isTupleOf } from "effect/Tuple"
    *
    * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
@@ -450,6 +489,7 @@ export {
    *   // ^? [number, number, number]
    * }
    *
+   * ```
    * @category guards
    * @since 3.3.0
    */
@@ -463,6 +503,7 @@ export {
    * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
    *
    * @example
+   * ```ts
    * import { isTupleOfAtLeast } from "effect/Tuple"
    *
    * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
@@ -475,6 +516,7 @@ export {
    *   // ^? [number, number, number, ...number[]]
    * }
    *
+   * ```
    * @category guards
    * @since 3.3.0
    */

package/src/Types.ts

@@ -15,6 +15,7 @@ type _TupleOf<T, N extends number, R extends Array<unknown>> = R["length"] exten
  * @typeParam T - The type of elements in the tuple.
  *
  * @example
+ * ```ts
  * import { TupleOf } from "effect/Types"
  *
  * // A tuple with exactly 3 numbers
@@ -23,6 +24,7 @@ type _TupleOf<T, N extends number, R extends Array<unknown>> = R["length"] exten
  * const example2: TupleOf<3, number> = [1, 2]; // invalid
  * // @ts-expect-error
  * const example3: TupleOf<3, number> = [1, 2, 3, 4]; // invalid
+ * ```
  *
  * @category tuples
  * @since 3.3.0
@@ -39,6 +41,7 @@ export type TupleOf<N extends number, T> = N extends N ? number extends N ? Arra
  * @typeParam T - The type of elements in the tuple.
  *
  * @example
+ * ```ts
  * import { TupleOfAtLeast } from "effect/Types"
  *
  * // A tuple with at least 3 numbers
@@ -46,6 +49,7 @@ export type TupleOf<N extends number, T> = N extends N ? number extends N ? Arra
  * const example2: TupleOfAtLeast<3, number> = [1, 2, 3, 4, 5]; // valid
  * // @ts-expect-error
  * const example3: TupleOfAtLeast<3, number> = [1, 2]; // invalid
+ * ```
  *
  * @category tuples
  * @since 3.3.0
@@ -55,9 +59,11 @@ export type TupleOfAtLeast<N extends number, T> = [...TupleOf<N, T>, ...Array<T>
 /**
  * Returns the tags in a type.
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type Res = Types.Tags<string | { _tag: "a" } | { _tag: "b" } > // "a" | "b"
+ * ```
  *
  * @category types
  * @since 2.0.0
@@ -67,9 +73,11 @@ export type Tags<E> = E extends { _tag: string } ? E["_tag"] : never
 /**
  * Excludes the tagged object from the type.
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type Res = Types.ExcludeTag<string | { _tag: "a" } | { _tag: "b" }, "a"> // string | { _tag: "b" }
+ * ```
  *
  * @category types
  * @since 2.0.0
@@ -80,9 +88,11 @@ export type ExcludeTag<E, K extends Tags<E>> = Exclude<E, { _tag: K }>
  * Extracts the type of the given tag.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type Res = Types.ExtractTag<{ _tag: "a", a: number } | { _tag: "b", b: number }, "b"> // { _tag: "b", b: number }
+ * ```
  *
  * @category types
  * @since 2.0.0
@@ -102,9 +112,11 @@ export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) ext
  * Simplifies the type signature of a type.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type Res = Types.Simplify<{ a: number } & { b: number }> // { a: number; b: number; }
+ * ```
  *
  * @since 2.0.0
  * @category types
@@ -117,10 +129,12 @@ export type Simplify<A> = {
  * Determines if two types are equal.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type Res1 = Types.Equals<{ a: number }, { a: number }> // true
  * type Res2 = Types.Equals<{ a: number }, { b: number }> // false
+ * ```
  *
  * @since 2.0.0
  * @category models
@@ -134,10 +148,12 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
  * Determines if a record contains any of the given keys.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type Res1 = Types.Has<{ a: number }, "a" | "b"> // true
  * type Res2 = Types.Has<{ c: number }, "a" | "b"> // false
+ * ```
  *
  * @since 2.0.0
  * @category models
@@ -150,8 +166,10 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  * Merges two object where the keys of the left object take precedence in the case of a conflict.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  * type MergeLeft = Types.MergeLeft<{ a: number, b: number; }, { a: string }> // { a: number; b: number; }
+ * ```
  *
  * @since 2.0.0
  * @category models
@@ -162,8 +180,10 @@ export type MergeLeft<Source, Target> = MergeRight<Target, Source>
  * Merges two object where the keys of the right object take precedence in the case of a conflict.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  * type MergeRight = Types.MergeRight<{ a: number, b: number; }, { a: string }> // { a: string; b: number; }
+ * ```
  *
  * @since 2.0.0
  * @category models
@@ -193,6 +213,7 @@ export type Concurrency = number | "unbounded" | "inherit"
  * Make all properties in `T` mutable. Supports arrays, tuples, and records as well.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type MutableStruct = Types.Mutable<{ readonly a: string; readonly b: number }> // { a: string; b: number; }
@@ -202,6 +223,7 @@ export type Concurrency = number | "unbounded" | "inherit"
  * type MutableTuple = Types.Mutable<readonly [string, number]> // [string, number]
  *
  * type MutableRecord = Types.Mutable<{ readonly [_: string]: number }> // { [x: string]: number; }
+ * ```
  *
  * @since 2.0.0
  * @category types
@@ -214,6 +236,7 @@ export type Mutable<T> = {
  * Like `Types.Mutable`, but works recursively.
  *
  * @example
+ * ```ts
  * import type { Types } from "effect"
  *
  * type DeepMutableStruct = Types.DeepMutable<{
@@ -221,6 +244,7 @@ export type Mutable<T> = {
  *   readonly b: readonly string[]
  * }>
  * // { a: string; b: string[] }
+ * ```
  *
  * @since 3.1.0
  * @category types

package/src/Utils.ts

@@ -791,3 +791,11 @@ const tracingFunction = (name: string) => {
  * @category tracing
  */
 export const internalCall = tracingFunction("effect_internal_function")
+
+const genConstructor = (function*() {}).constructor
+
+/**
+ * @since 3.11.0
+ */
+export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any, any, any> =>
+  isObject(u) && u.constructor === genConstructor

package/src/internal/channel/channelExecutor.ts

@@ -7,7 +7,7 @@ import * as Effect from "../../Effect.js"
 import * as ExecutionStrategy from "../../ExecutionStrategy.js"
 import * as Exit from "../../Exit.js"
 import * as Fiber from "../../Fiber.js"
-import { identity, pipe } from "../../Function.js"
+import { dual, identity, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import * as Scope from "../../Scope.js"
 import type * as UpstreamPullStrategy from "../../UpstreamPullStrategy.js"
@@ -1092,14 +1092,18 @@ export const readUpstream = <A, E2, R, E>(
 }
 
 /** @internal */
-export const run = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => pipe(runScoped(self), Effect.scoped)
-
-/** @internal */
-export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env | Scope.Scope> => {
+export const runIn = dual<
+  (scope: Scope.Scope) => <Env, InErr, InDone, OutErr, OutDone>(
+    self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
+  ) => Effect.Effect<OutDone, OutErr, Env>,
+  <Env, InErr, InDone, OutErr, OutDone>(
+    self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>,
+    scope: Scope.Scope
+  ) => Effect.Effect<OutDone, OutErr, Env>
+>(2, <Env, InErr, InDone, OutErr, OutDone>(
+  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>,
+  scope: Scope.Scope
+) => {
   const run = (
     channelDeferred: Deferred.Deferred<OutDone, OutErr>,
     scopeDeferred: Deferred.Deferred<void>,
@@ -1109,8 +1113,7 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
       Effect.sync(() => new ChannelExecutor(self, void 0, identity)),
       (exec) =>
         Effect.suspend(() =>
-          pipe(
-            runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec),
+          runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec).pipe(
             Effect.intoDeferred(channelDeferred),
             Effect.zipRight(Deferred.await(channelDeferred)),
             Effect.zipLeft(Deferred.await(scopeDeferred))
@@ -1128,33 +1131,34 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
       }
     )
   return Effect.uninterruptibleMask((restore) =>
-    Effect.flatMap(Effect.scope, (parent) =>
-      pipe(
-        Effect.all([
-          Scope.fork(parent, ExecutionStrategy.sequential),
-          Deferred.make<OutDone, OutErr>(),
-          Deferred.make<void>()
-        ]),
-        Effect.flatMap(([child, channelDeferred, scopeDeferred]) =>
-          pipe(
-            Effect.forkScoped(restore(run(channelDeferred, scopeDeferred, child))),
-            Effect.flatMap((fiber) =>
-              pipe(
-                Scope.addFinalizer(
-                  parent,
-                  Deferred.succeed(scopeDeferred, void 0).pipe(
-                    Effect.zipRight(Effect.yieldNow())
+    Effect.all([
+      Scope.fork(scope, ExecutionStrategy.sequential),
+      Deferred.make<OutDone, OutErr>(),
+      Deferred.make<void>()
+    ]).pipe(Effect.flatMap(([child, channelDeferred, scopeDeferred]) =>
+      restore(run(channelDeferred, scopeDeferred, child)).pipe(
+        Effect.forkIn(scope),
+        Effect.flatMap((fiber) =>
+          scope.addFinalizer(() =>
+            Deferred.isDone(channelDeferred).pipe(
+              Effect.flatMap((isDone) =>
+                isDone
+                  ? Deferred.succeed(scopeDeferred, void 0).pipe(
+                    Effect.zipRight(Fiber.await(fiber)),
+                    Effect.zipRight(Fiber.inheritAll(fiber))
+                  )
+                  : Deferred.succeed(scopeDeferred, void 0).pipe(
+                    Effect.zipRight(Fiber.interrupt(fiber)),
+                    Effect.zipRight(Fiber.inheritAll(fiber))
                   )
-                ),
-                Effect.zipRight(restore(Deferred.await(channelDeferred))),
-                Effect.zipLeft(Fiber.inheritAll(fiber))
               )
             )
-          )
+          ).pipe(Effect.zipRight(restore(Deferred.await(channelDeferred))))
         )
-      ))
+      )
+    ))
   )
-}
+})
 
 /** @internal */
 const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(