effect 3.12.11 → 3.13.0

package/src/Schema.ts

@@ -2,6 +2,7 @@
  * @since 3.10.0
  */
 
+import type { StandardSchemaV1 } from "@standard-schema/spec"
 import type { ArbitraryAnnotation, ArbitraryGenerationContext, LazyArbitrary } from "./Arbitrary.js"
 import * as array_ from "./Array.js"
 import * as bigDecimal_ from "./BigDecimal.js"
@@ -44,6 +45,7 @@ import type * as pretty_ from "./Pretty.js"
 import * as record_ from "./Record.js"
 import * as redacted_ from "./Redacted.js"
 import * as Request from "./Request.js"
+import * as scheduler_ from "./Scheduler.js"
 import type { ParseOptions } from "./SchemaAST.js"
 import * as AST from "./SchemaAST.js"
 import * as sortedSet_ from "./SortedSet.js"
@@ -128,6 +130,81 @@ const variance = {
   _R: (_: never) => _
 }
 
+const makeStandardResult = <A>(exit: exit_.Exit<StandardSchemaV1.Result<A>>): StandardSchemaV1.Result<A> =>
+  exit_.isSuccess(exit) ? exit.value : makeStandardFailureResult(cause_.pretty(exit.cause))
+
+const makeStandardFailureResult = (message: string): StandardSchemaV1.FailureResult => ({
+  issues: [{ message }]
+})
+
+const makeStandardFailureFromParseIssue = (
+  issue: ParseResult.ParseIssue
+): Effect.Effect<StandardSchemaV1.FailureResult> =>
+  Effect.map(ParseResult.ArrayFormatter.formatIssue(issue), (issues) => ({
+    issues: issues.map((issue) => ({
+      path: issue.path,
+      message: issue.message
+    }))
+  }))
+
+/**
+ * Returns a "Standard Schema" object conforming to the [Standard Schema
+ * v1](https://standardschema.dev/) specification.
+ *
+ * This function creates a schema whose `validate` method attempts to decode and
+ * validate the provided input synchronously. If the underlying `Schema`
+ * includes any asynchronous components (e.g., asynchronous message resolutions
+ * or checks), then validation will necessarily return a `Promise` instead.
+ *
+ * Any detected defects will be reported via a single issue containing no
+ * `path`.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ *
+ * const schema = Schema.Struct({
+ *   name: Schema.String
+ * })
+ *
+ * //      ┌─── StandardSchemaV1<{ readonly name: string; }>
+ * //      ▼
+ * const standardSchema = Schema.standardSchemaV1(schema)
+ * ```
+ *
+ * @category Standard Schema
+ * @since 3.13.0
+ */
+export const standardSchemaV1 = <A, I>(schema: Schema<A, I, never>): StandardSchemaV1<I, A> => {
+  const decodeUnknown = ParseResult.decodeUnknown(schema)
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "effect",
+      validate(value) {
+        const scheduler = new scheduler_.SyncScheduler()
+        const fiber = Effect.runFork(
+          Effect.matchEffect(decodeUnknown(value), {
+            onFailure: makeStandardFailureFromParseIssue,
+            onSuccess: (value) => Effect.succeed({ value })
+          }),
+          { scheduler }
+        )
+        scheduler.flush()
+        const exit = fiber.unsafePoll()
+        if (exit) {
+          return makeStandardResult(exit)
+        }
+        return new Promise((resolve) => {
+          fiber.addObserver((exit) => {
+            resolve(makeStandardResult(exit))
+          })
+        })
+      }
+    }
+  }
+}
+
 interface AllAnnotations<A, TypeParameters extends ReadonlyArray<any>>
   extends Annotations.Schema<A, TypeParameters>, PropertySignature.Annotations<A>
 {}
@@ -8677,7 +8754,7 @@ type ClassAnnotations<Self, A> =
   | Annotations.Schema<Self>
   | readonly [
     Annotations.Schema<Self> | undefined,
-    Annotations.Schema<Self>?,
+    (Annotations.Schema<Self> | undefined)?,
     Annotations.Schema<A>?
   ]
 
@@ -8956,7 +9033,7 @@ export const TaggedClass = <Self = never>(identifier?: string) =>
 <Tag extends string, Fields extends Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self, Struct.Type<{ readonly _tag: tag<Tag> } & Fields>>
 ): [Self] extends [never] ? MissingSelfGeneric<"TaggedClass", `"Tag", `>
   : TaggedClass<Self, Tag, { readonly _tag: tag<Tag> } & Fields> =>
 {
@@ -9019,7 +9096,7 @@ export const TaggedError = <Self = never>(identifier?: string) =>
 <Tag extends string, Fields extends Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self, Struct.Type<{ readonly _tag: tag<Tag> } & Fields>>
 ): [Self] extends [never] ? MissingSelfGeneric<"TaggedError", `"Tag", `>
   : TaggedErrorClass<
     Self,
@@ -10825,7 +10902,7 @@ export const TaggedRequest =
       success: Success
       payload: Payload
     },
-    annotations?: Annotations.Schema<Self>
+    annotations?: ClassAnnotations<Self, Struct.Type<{ readonly _tag: tag<Tag> } & Payload>>
   ): [Self] extends [never] ? MissingSelfGeneric<"TaggedRequest", `"Tag", SuccessSchema, FailureSchema, `>
     : TaggedRequestClass<
       Self,

package/src/Stream.ts

@@ -6743,10 +6743,7 @@ export const provideService: {
    * @since 2.0.0
    * @category context
    */
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    resource: Context.Tag.Service<T>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>
+  <I, S>(tag: Context.Tag<I, S>, resource: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>
   /**
    * Provides the stream with the single service it requires. If the stream
    * requires more than one service use `Stream.provideContext` instead.
@@ -6754,11 +6751,7 @@ export const provideService: {
    * @since 2.0.0
    * @category context
    */
-  <A, E, R, T extends Context.Tag<any, any>>(
-    self: Stream<A, E, R>,
-    tag: T,
-    resource: Context.Tag.Service<T>
-  ): Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>
+  <A, E, R, I, S>(self: Stream<A, E, R>, tag: Context.Tag<I, S>, resource: NoInfer<S>): Stream<A, E, Exclude<R, I>>
 } = internal.provideService
 
 /**
@@ -6776,10 +6769,10 @@ export const provideServiceEffect: {
    * @since 2.0.0
    * @category context
    */
-  <T extends Context.Tag<any, any>, E2, R2>(
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>
+  <I, S, E2, R2>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<NoInfer<S>, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, I>>
   /**
    * Provides the stream with the single service it requires. If the stream
    * requires more than one service use `Stream.provideContext` instead.
@@ -6787,11 +6780,11 @@ export const provideServiceEffect: {
    * @since 2.0.0
    * @category context
    */
-  <A, E, R, T extends Context.Tag<any, any>, E2, R2>(
+  <A, E, R, I, S, E2, R2>(
     self: Stream<A, E, R>,
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>
-  ): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<NoInfer<S>, E2, R2>
+  ): Stream<A, E2 | E, R2 | Exclude<R, I>>
 } = internal.provideServiceEffect
 
 /**
@@ -6809,10 +6802,10 @@ export const provideServiceStream: {
    * @since 2.0.0
    * @category context
    */
-  <T extends Context.Tag<any, any>, E2, R2>(
-    tag: T,
-    stream: Stream<Context.Tag.Service<T>, E2, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>
+  <I, S, E2, R2>(
+    tag: Context.Tag<I, S>,
+    stream: Stream<NoInfer<S>, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, I>>
   /**
    * Provides the stream with the single service it requires. If the stream
    * requires more than one service use `Stream.provideContext` instead.
@@ -6820,11 +6813,11 @@ export const provideServiceStream: {
    * @since 2.0.0
    * @category context
    */
-  <A, E, R, T extends Context.Tag<any, any>, E2, R2>(
+  <A, E, R, I, S, E2, R2>(
     self: Stream<A, E, R>,
-    tag: T,
-    stream: Stream<Context.Tag.Service<T>, E2, R2>
-  ): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>
+    tag: Context.Tag<I, S>,
+    stream: Stream<NoInfer<S>, E2, R2>
+  ): Stream<A, E2 | E, R2 | Exclude<R, I>>
 } = internal.provideServiceStream
 
 /**
@@ -10028,21 +10021,21 @@ export const updateService: {
    * @since 2.0.0
    * @category context
    */
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, T | R>
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    f: (service: NoInfer<S>) => NoInfer<S>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, I | R>
   /**
    * Updates the specified service within the context of the `Stream`.
    *
    * @since 2.0.0
    * @category context
    */
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <A, E, R, I, S>(
     self: Stream<A, E, R>,
-    tag: T,
-    f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ): Stream<A, E, R | T>
+    tag: Context.Tag<I, S>,
+    f: (service: NoInfer<S>) => NoInfer<S>
+  ): Stream<A, E, I | R>
 } = internal.updateService
 
 /**

package/src/Trie.ts

@@ -34,7 +34,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pipeable, Inspectable {
+export interface Trie<out Value> extends Iterable<[string, Value]>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
     readonly _Value: Covariant<Value>
   }
@@ -145,7 +145,7 @@ export const insert: {
    * @since 2.0.0
    * @category mutations
    */
-  <V>(key: string, value: V): (self: Trie<V>) => Trie<V>
+  <V1>(key: string, value: V1): <V>(self: Trie<V>) => Trie<V | V1>
   /**
    * Insert a new entry in the `Trie`.
    *
@@ -169,7 +169,7 @@ export const insert: {
    * @since 2.0.0
    * @category mutations
    */
-  <V>(self: Trie<V>, key: string, value: V): Trie<V>
+  <V1, V>(self: Trie<V>, key: string, value: V1): Trie<V | V1>
 } = TR.insert
 
 /**
@@ -1605,7 +1605,7 @@ export const modify: {
    * @since 2.0.0
    * @category mutations
    */
-  <V>(key: string, f: (v: V) => V): (self: Trie<V>) => Trie<V>
+  <V1, V>(key: string, f: (v: V) => V1): (self: Trie<V>) => Trie<V1 | V>
   /**
    * Updates the value of the specified key within the `Trie` if it exists.
    *
@@ -1627,7 +1627,7 @@ export const modify: {
    * @since 2.0.0
    * @category mutations
    */
-  <V>(self: Trie<V>, key: string, f: (v: V) => V): Trie<V>
+  <V1, V>(self: Trie<V>, key: string, f: (v: V) => V1): Trie<V | V1>
 } = TR.modify
 
 /**
@@ -1760,7 +1760,7 @@ export const insertMany: {
    * @since 2.0.0
    * @category mutations
    */
-  <V>(iter: Iterable<[string, V]>): (self: Trie<V>) => Trie<V>
+  <V1>(iter: Iterable<[string, V1]>): <V>(self: Trie<V>) => Trie<V | V1>
   /**
    * Insert multiple entries in the `Trie` at once.
    *
@@ -1790,5 +1790,5 @@ export const insertMany: {
    * @since 2.0.0
    * @category mutations
    */
-  <V>(self: Trie<V>, iter: Iterable<[string, V]>): Trie<V>
+  <V1, V>(self: Trie<V>, iter: Iterable<[string, V1]>): Trie<V | V1>
 } = TR.insertMany

package/src/index.ts

@@ -447,6 +447,31 @@ export * as Mailbox from "./Mailbox.js"
 export * as ManagedRuntime from "./ManagedRuntime.js"
 
 /**
+ * The `effect/match` module provides a type-safe pattern matching system for
+ * TypeScript. Inspired by functional programming, it simplifies conditional
+ * logic by replacing verbose if/else or switch statements with a structured and
+ * expressive API.
+ *
+ * This module supports matching against types, values, and discriminated unions
+ * while enforcing exhaustiveness checking to ensure all cases are handled.
+ *
+ * Although pattern matching is not yet a native JavaScript feature,
+ * `effect/match` offers a reliable implementation that is available today.
+ *
+ * **How Pattern Matching Works**
+ *
+ * Pattern matching follows a structured process:
+ *
+ * - **Creating a matcher**: Define a `Matcher` that operates on either a
+ *   specific `Match.type` or `Match.value`.
+ *
+ * - **Defining patterns**: Use combinators such as `Match.when`, `Match.not`,
+ *   and `Match.tag` to specify matching conditions.
+ *
+ * - **Completing the match**: Apply a finalizer such as `Match.exhaustive`,
+ *   `Match.orElse`, or `Match.option` to determine how unmatched cases should
+ *   be handled.
+ *
  * @since 1.0.0
  */
 export * as Match from "./Match.js"

package/src/internal/channel.ts

@@ -23,6 +23,7 @@ import * as Ref from "../Ref.js"
 import * as Scope from "../Scope.js"
 import type * as SingleProducerAsyncInput from "../SingleProducerAsyncInput.js"
 import type * as Tracer from "../Tracer.js"
+import type * as Types from "../Types.js"
 import * as executor from "./channel/channelExecutor.js"
 import type * as ChannelState from "./channel/channelState.js"
 import * as mergeDecision from "./channel/mergeDecision.js"
@@ -1960,22 +1961,22 @@ export const pipeToOrFail = dual<
 
 /** @internal */
 export const provideService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    service: Context.Tag.Service<T>
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
   ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, T extends Context.Tag<any, any>>(
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, I>>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, I, S>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    tag: T,
-    service: Context.Tag.Service<T>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>>
->(3, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, T extends Context.Tag<any, any>>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, I>>
+>(3, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, I, S>(
   self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  tag: T,
-  service: Context.Tag.Service<T>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>> => {
+  tag: Context.Tag<I, S>,
+  service: Types.NoInfer<S>
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, I>> => {
   return core.flatMap(
     context<any>(),
     (context) => core.provideContext(self, Context.add(context, tag, service))
@@ -2089,31 +2090,28 @@ export const scopedWith = <A, E, R>(
   unwrapScoped(Effect.map(Effect.scope, (scope) => core.flatMap(core.fromEffect(f(scope)), core.write)))
 
 /** @internal */
-export const service = <T extends Context.Tag<any, any>>(
-  tag: T
-): Channel.Channel<never, unknown, never, unknown, Context.Tag.Service<T>, unknown, Context.Tag.Identifier<T>> =>
-  core.fromEffect(tag)
+export const service = <I, S>(
+  tag: Context.Tag<I, S>
+): Channel.Channel<never, unknown, never, unknown, S, unknown, I> => core.fromEffect(tag)
 
 /** @internal */
-export const serviceWith = <T extends Context.Tag<any, any>>(tag: T) =>
+export const serviceWith = <I, S>(tag: Context.Tag<I, S>) =>
 <OutDone>(
-  f: (resource: Context.Tag.Service<T>) => OutDone
-): Channel.Channel<never, unknown, never, unknown, OutDone, unknown, Context.Tag.Identifier<T>> => map(service(tag), f)
+  f: (resource: Types.NoInfer<S>) => OutDone
+): Channel.Channel<never, unknown, never, unknown, OutDone, unknown, I> => map(service(tag), f)
 
 /** @internal */
 export const serviceWithChannel =
-  <T extends Context.Tag<any, any>>(tag: T) =>
+  <I, S>(tag: Context.Tag<I, S>) =>
   <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    f: (resource: Context.Tag.Service<T>) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Context.Tag.Identifier<T>> =>
-    core.flatMap(service(tag), f)
+    f: (resource: Types.NoInfer<S>) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I> => core.flatMap(service(tag), f)
 
 /** @internal */
-export const serviceWithEffect = <T extends Context.Tag<any, any>>(tag: T) =>
+export const serviceWithEffect = <I, S>(tag: Context.Tag<I, S>) =>
 <Env, OutErr, OutDone>(
-  f: (resource: Context.Tag.Service<T>) => Effect.Effect<OutDone, OutErr, Env>
-): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | Context.Tag.Identifier<T>> =>
-  mapEffect(service(tag), f)
+  f: (resource: Types.NoInfer<S>) => Effect.Effect<OutDone, OutErr, Env>
+): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | I> => mapEffect(service(tag), f)
 
 /** @internal */
 export const splitLines = <Err, Done>(): Channel.Channel<
@@ -2334,22 +2332,22 @@ export const unwrapScopedWith = <OutElem, InElem, OutErr, InErr, OutDone, InDone
 
 /** @internal */
 export const updateService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    f: (resource: Types.NoInfer<S>) => Types.NoInfer<S>
   ) => <OutElem, OutErr, InErr, OutDone, InDone, R>(
     self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>
-  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, T | R>,
-  <OutElem, OutErr, InErr, OutDone, InDone, R, T extends Context.Tag<any, any>>(
+  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, I | R>,
+  <OutElem, OutErr, InErr, OutDone, InDone, R, I, S>(
     self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
-    tag: T,
-    f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, T | R>
->(3, <OutElem, OutErr, InErr, OutDone, InDone, R, T extends Context.Tag<any, any>>(
+    tag: Context.Tag<I, S>,
+    f: (resource: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, I | R>
+>(3, <OutElem, OutErr, InErr, OutDone, InDone, R, I, S>(
   self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
-  tag: T,
-  f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-): Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R | T> =>
+  tag: Context.Tag<I, S>,
+  f: (resource: Types.NoInfer<S>) => Types.NoInfer<S>
+): Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R | I> =>
   mapInputContext(self, (context: Context.Context<R>) =>
     Context.merge(
       context,