effect 3.10.19 → 3.11.0

package/src/STM.ts

@@ -106,6 +106,8 @@ export interface STMTypeLambda extends TypeLambda {
  */
 declare module "./Context.js" {
   interface Tag<Id, Value> extends STM<Value, never, Id> {}
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface Reference<Id, Value> extends STM<Value> {}
 }
 
 /**

package/src/Schema.ts

@@ -5041,6 +5041,10 @@ export class UUID extends String$.pipe(
     schemaId: UUIDSchemaId,
     identifier: "UUID",
     title: "UUID",
+    jsonSchema: {
+      format: "uuid",
+      pattern: uuidRegexp.source
+    },
     description: "a Universally Unique Identifier",
     arbitrary: (): LazyArbitrary<string> => (fc) => fc.uuid()
   })
@@ -5073,6 +5077,49 @@ export class ULID extends String$.pipe(
   })
 ) {}
 
+/**
+ * Defines a schema that represents a `URL` object.
+ *
+ * @category URL constructors
+ * @since 3.11.0
+ */
+export class URLFromSelf extends instanceOf(URL, {
+  identifier: "URLFromSelf",
+  title: "URLFromSelf",
+  arbitrary: (): LazyArbitrary<URL> => (fc) => fc.webUrl().map((s) => new URL(s)),
+  pretty: () => (url) => url.toString()
+}) {}
+
+/** @ignore */
+class URL$ extends transformOrFail(
+  String$.annotations({ description: "a string that will be parsed into a URL" }),
+  URLFromSelf,
+  {
+    strict: true,
+    decode: (str, _, ast) =>
+      ParseResult.try({
+        try: () => new URL(str),
+        catch: () => new ParseResult.Type(ast, str)
+      }),
+    encode: (url) => ParseResult.succeed(url.toString())
+  }
+).annotations({
+  identifier: "URL",
+  title: "URL",
+  pretty: () => (url) => url.toString()
+}) {}
+
+export {
+  /**
+   * Defines a schema that attempts to convert a `string` to a `URL` object using
+   * the `new URL` constructor.
+   *
+   * @category URL transformations
+   * @since 3.11.0
+   */
+  URL$ as URL
+}
+
 /**
  * @category schema id
  * @since 3.10.0
@@ -9793,6 +9840,19 @@ export class BooleanFromUnknown extends transform(
   { strict: true, decode: Predicate.isTruthy, encode: identity }
 ).annotations({ identifier: "BooleanFromUnknown" }) {}
 
+/**
+ * Converts an `string` value into its corresponding `boolean`
+ * ("true" as `true` and "false" as `false`).
+ *
+ * @category boolean transformations
+ * @since 3.11.0
+ */
+export class BooleanFromString extends transform(
+  Literal("true", "false"),
+  Boolean$,
+  { strict: true, decode: (value) => value === "true", encode: (value) => value ? "true" : "false" }
+).annotations({ identifier: "BooleanFromString" }) {}
+
 /**
  * @category Config validations
  * @since 3.10.0

package/src/Sink.ts

@@ -1765,6 +1765,17 @@ export const unwrapScoped: <A, In, L, E, R>(
   effect: Effect.Effect<Sink<A, In, L, E, R>, E, R>
 ) => Sink<A, In, L, E, Exclude<R, Scope.Scope>> = internal.unwrapScoped
 
+/**
+ * Constructs a `Sink` from a function which receives a `Scope` and returns
+ * an effect that will result in a `Sink` if successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const unwrapScopedWith: <A, In, L, E, R>(
+  f: (scope: Scope.Scope) => Effect.Effect<Sink<A, In, L, E, R>, E, R>
+) => Sink<A, In, L, E, R> = internal.unwrapScopedWith
+
 /**
  * Returns the sink that executes this one and times its execution.
  *

package/src/Stream.ts

@@ -6162,8 +6162,8 @@ export const paginateEffect: <S, A, E, R>(
 
 /**
  * Partition a stream using a predicate. The first stream will contain all
- * element evaluated to true and the second one will contain all element
- * evaluated to false. The faster stream may advance by up to buffer elements
+ * element evaluated to false and the second one will contain all element
+ * evaluated to true. The faster stream may advance by up to buffer elements
  * further than the slower one.
  *
  * @example
@@ -6176,15 +6176,15 @@ export const paginateEffect: <S, A, E, R>(
  *
  * const program = Effect.scoped(
  *   Effect.gen(function*() {
- *     const [evens, odds] = yield* partition
- *     console.log(yield* Stream.runCollect(evens))
+ *     const [odds, evens] = yield* partition
  *     console.log(yield* Stream.runCollect(odds))
+ *     console.log(yield* Stream.runCollect(evens))
  *   })
  * )
  *
  * // Effect.runPromise(program)
- * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
  * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+ * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
  * ```
  *
  * @since 2.0.0
@@ -6193,8 +6193,8 @@ export const paginateEffect: <S, A, E, R>(
 export const partition: {
   /**
    * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to true and the second one will contain all element
-   * evaluated to false. The faster stream may advance by up to buffer elements
+   * element evaluated to false and the second one will contain all element
+   * evaluated to true. The faster stream may advance by up to buffer elements
    * further than the slower one.
    *
    * @example
@@ -6207,15 +6207,15 @@ export const partition: {
    *
    * const program = Effect.scoped(
    *   Effect.gen(function*() {
-   *     const [evens, odds] = yield* partition
-   *     console.log(yield* Stream.runCollect(evens))
+   *     const [odds, evens] = yield* partition
    *     console.log(yield* Stream.runCollect(odds))
+   *     console.log(yield* Stream.runCollect(evens))
    *   })
    * )
    *
    * // Effect.runPromise(program)
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * ```
    *
    * @since 2.0.0
@@ -6229,8 +6229,8 @@ export const partition: {
   ) => Effect.Effect<[excluded: Stream<Exclude<C, B>, E, never>, satisfying: Stream<B, E, never>], E, R | Scope.Scope>
   /**
    * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to true and the second one will contain all element
-   * evaluated to false. The faster stream may advance by up to buffer elements
+   * element evaluated to false and the second one will contain all element
+   * evaluated to true. The faster stream may advance by up to buffer elements
    * further than the slower one.
    *
    * @example
@@ -6243,15 +6243,15 @@ export const partition: {
    *
    * const program = Effect.scoped(
    *   Effect.gen(function*() {
-   *     const [evens, odds] = yield* partition
-   *     console.log(yield* Stream.runCollect(evens))
+   *     const [odds, evens] = yield* partition
    *     console.log(yield* Stream.runCollect(odds))
+   *     console.log(yield* Stream.runCollect(evens))
    *   })
    * )
    *
    * // Effect.runPromise(program)
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * ```
    *
    * @since 2.0.0
@@ -6265,8 +6265,8 @@ export const partition: {
   ) => Effect.Effect<[excluded: Stream<A, E, never>, satisfying: Stream<A, E, never>], E, Scope.Scope | R>
   /**
    * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to true and the second one will contain all element
-   * evaluated to false. The faster stream may advance by up to buffer elements
+   * element evaluated to false and the second one will contain all element
+   * evaluated to true. The faster stream may advance by up to buffer elements
    * further than the slower one.
    *
    * @example
@@ -6279,15 +6279,15 @@ export const partition: {
    *
    * const program = Effect.scoped(
    *   Effect.gen(function*() {
-   *     const [evens, odds] = yield* partition
-   *     console.log(yield* Stream.runCollect(evens))
+   *     const [odds, evens] = yield* partition
    *     console.log(yield* Stream.runCollect(odds))
+   *     console.log(yield* Stream.runCollect(evens))
    *   })
    * )
    *
    * // Effect.runPromise(program)
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * ```
    *
    * @since 2.0.0
@@ -6300,8 +6300,8 @@ export const partition: {
   ): Effect.Effect<[excluded: Stream<Exclude<C, B>, E, never>, satisfying: Stream<B, E, never>], E, R | Scope.Scope>
   /**
    * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to true and the second one will contain all element
-   * evaluated to false. The faster stream may advance by up to buffer elements
+   * element evaluated to false and the second one will contain all element
+   * evaluated to true. The faster stream may advance by up to buffer elements
    * further than the slower one.
    *
    * @example
@@ -6314,15 +6314,15 @@ export const partition: {
    *
    * const program = Effect.scoped(
    *   Effect.gen(function*() {
-   *     const [evens, odds] = yield* partition
-   *     console.log(yield* Stream.runCollect(evens))
+   *     const [odds, evens] = yield* partition
    *     console.log(yield* Stream.runCollect(odds))
+   *     console.log(yield* Stream.runCollect(evens))
    *   })
    * )
    *
    * // Effect.runPromise(program)
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
    * ```
    *
    * @since 2.0.0
@@ -7420,8 +7420,7 @@ export const run: {
  * @since 2.0.0
  * @category destructors
  */
-export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, Exclude<R, Scope.Scope>> =
-  internal.runCollect
+export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R> = internal.runCollect
 
 /**
  * Runs the stream and emits the number of elements processed
@@ -7429,8 +7428,7 @@ export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk
  * @since 2.0.0
  * @category destructors
  */
-export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, Exclude<R, Scope.Scope>> =
-  internal.runCount
+export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, R> = internal.runCount
 
 /**
  * Runs the stream only for its effects. The emitted elements are discarded.
@@ -7438,8 +7436,7 @@ export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number,
  * @since 2.0.0
  * @category destructors
  */
-export const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>> =
-  internal.runDrain
+export const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, R> = internal.runDrain
 
 /**
  * Executes a pure fold over the stream of values - reduces all elements in
@@ -7456,7 +7453,7 @@ export const runFold: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>
+  <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>
   /**
    * Executes a pure fold over the stream of values - reduces all elements in
    * the stream to a value of type `S`.
@@ -7464,7 +7461,7 @@ export const runFold: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Exclude<R, Scope.Scope>>
+  <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>
 } = internal.runFold
 
 /**
@@ -7571,11 +7568,7 @@ export const runFoldWhile: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A>(
-    s: S,
-    cont: Predicate<S>,
-    f: (s: S, a: A) => S
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>
+  <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>
   /**
    * Reduces the elements in the stream to a value of type `S`. Stops the fold
    * early when the condition is not fulfilled. Example:
@@ -7583,12 +7576,7 @@ export const runFoldWhile: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, S>(
-    self: Stream<A, E, R>,
-    s: S,
-    cont: Predicate<S>,
-    f: (s: S, a: A) => S
-  ): Effect.Effect<S, E, Exclude<R, Scope.Scope>>
+  <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>
 } = internal.runFoldWhile
 
 /**
@@ -8323,6 +8311,17 @@ export const scheduleWith: {
 export const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, Exclude<R, Scope.Scope>> =
   internal.scoped
 
+/**
+ * Use a function that receives a scope and returns an effect to emit an output
+ * element. The output element will be the result of the returned effect, if
+ * successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const scopedWith: <A, E, R>(f: (scope: Scope.Scope) => Effect.Effect<A, E, R>) => Stream<A, E, R> =
+  internal.scopedWith
+
 /**
  * Emits a sliding window of `n` elements.
  *
@@ -9914,6 +9913,18 @@ export const unwrapScoped: <A, E2, R2, E, R>(
   effect: Effect.Effect<Stream<A, E2, R2>, E, R>
 ) => Stream<A, E | E2, R2 | Exclude<R, Scope.Scope>> = internal.unwrapScoped
 
+/**
+ * Creates a stream produced from a function which receives a `Scope` and
+ * returns an `Effect`. The resulting stream will emit a single element, which
+ * will be the result of the returned effect, if successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const unwrapScopedWith: <A, E2, R2, E, R>(
+  f: (scope: Scope.Scope) => Effect.Effect<Stream<A, E2, R2>, E, R>
+) => Stream<A, E | E2, R | R2> = internal.unwrapScopedWith
+
 /**
  * Updates the specified service within the context of the `Stream`.
  *

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>(