effect 3.12.4 → 3.12.6

package/src/FiberMap.ts

@@ -101,14 +101,14 @@ const unsafeMake = <K, A = unknown, E = unknown>(
  * ```ts
  * import { Effect, FiberMap } from "effect"
  *
- * Effect.gen(function*(_) {
- *   const map = yield* _(FiberMap.make<string>())
+ * Effect.gen(function*() {
+ *   const map = yield* FiberMap.make<string>()
  *
  *   // run some effects and add the fibers to the map
- *   yield* _(FiberMap.run(map, "fiber a", Effect.never))
- *   yield* _(FiberMap.run(map, "fiber b", Effect.never))
+ *   yield* FiberMap.run(map, "fiber a", Effect.never)
+ *   yield* FiberMap.run(map, "fiber b", Effect.never)
  *
- *   yield* _(Effect.sleep(1000))
+ *   yield* Effect.sleep(1000)
  * }).pipe(
  *   Effect.scoped // The fibers will be interrupted when the scope is closed
  * )
@@ -619,9 +619,9 @@ export const run: {
  *    getAll: Effect.Effect<Array<unknown>>
  * }>("Users")
  *
- * Effect.gen(function*(_) {
- *   const map = yield* _(FiberMap.make<string>())
- *   const run = yield* _(FiberMap.runtime(map)<Users>())
+ * Effect.gen(function*() {
+ *   const map = yield* FiberMap.make<string>()
+ *   const run = yield* FiberMap.runtime(map)<Users>()
  *
  *   // run some effects and add the fibers to the map
  *   run("effect-a", Effect.andThen(Users, _ => _.getAll))

package/src/FiberSet.ts

@@ -98,14 +98,14 @@ const unsafeMake = <A, E>(
  * ```ts
  * import { Effect, FiberSet } from "effect"
  *
- * Effect.gen(function*(_) {
- *   const set = yield* _(FiberSet.make())
+ * Effect.gen(function*() {
+ *   const set = yield* FiberSet.make()
  *
  *   // run some effects and add the fibers to the set
- *   yield* _(FiberSet.run(set, Effect.never))
- *   yield* _(FiberSet.run(set, Effect.never))
+ *   yield* FiberSet.run(set, Effect.never)
+ *   yield* FiberSet.run(set, Effect.never)
  *
- *   yield* _(Effect.sleep(1000))
+ *   yield* Effect.sleep(1000)
  * }).pipe(
  *   Effect.scoped // The fibers will be interrupted when the scope is closed
  * )
@@ -372,9 +372,9 @@ export const run: {
  *    getAll: Effect.Effect<Array<unknown>>
  * }>("Users")
  *
- * Effect.gen(function*(_) {
- *   const set = yield* _(FiberSet.make())
- *   const run = yield* _(FiberSet.runtime(set)<Users>())
+ * Effect.gen(function*() {
+ *   const set = yield* FiberSet.make()
+ *   const run = yield* FiberSet.runtime(set)<Users>()
  *
  *   // run some effects and add the fibers to the set
  *   run(Effect.andThen(Users, _ => _.getAll))

package/src/Inspectable.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-
 import type * as FiberRefs from "./FiberRefs.js"
 import { globalValue } from "./GlobalValue.js"
 import { hasProperty, isFunction } from "./Predicate.js"

package/src/LogLevel.ts

@@ -171,24 +171,108 @@ export const None: LogLevel = core.logLevelNone
 export const allLevels = core.allLogLevels
 
 /**
- * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
- * to the previous `LogLevel` after the `Effect` workflow completes.
+ * Temporarily sets a `LogLevel` for an `Effect` workflow.
+ *
+ * **Details**
+ *
+ * This function allows you to apply a specific `LogLevel` locally to an
+ * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its
+ * previous state.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful when you want to adjust the verbosity of logging
+ * for specific parts of your program without affecting the global log level.
+ *
+ * @example
+ * ```ts
+ * import { Effect, LogLevel } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("message1")
+ *   yield* Effect.gen(function*() {
+ *     yield* Effect.log("message2")
+ *     yield* Effect.log("message3")
+ *   }).pipe(LogLevel.locally(LogLevel.Warning))
+ * })
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message=message1
+ * // timestamp=... level=WARN fiber=#0 message=message2
+ * // timestamp=... level=WARN fiber=#0 message=message3
+ * ```
  *
  * @since 2.0.0
  * @category utils
  */
 export const locally: {
   /**
-   * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
-   * to the previous `LogLevel` after the `Effect` workflow completes.
+   * Temporarily sets a `LogLevel` for an `Effect` workflow.
+   *
+   * **Details**
+   *
+   * This function allows you to apply a specific `LogLevel` locally to an
+   * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its
+   * previous state.
+   *
+   * **When to Use**
+   *
+   * This is particularly useful when you want to adjust the verbosity of logging
+   * for specific parts of your program without affecting the global log level.
+   *
+   * @example
+   * ```ts
+   * import { Effect, LogLevel } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   yield* Effect.log("message1")
+   *   yield* Effect.gen(function*() {
+   *     yield* Effect.log("message2")
+   *     yield* Effect.log("message3")
+   *   }).pipe(LogLevel.locally(LogLevel.Warning))
+   * })
+   *
+   * // Effect.runFork(program)
+   * // timestamp=... level=INFO fiber=#0 message=message1
+   * // timestamp=... level=WARN fiber=#0 message=message2
+   * // timestamp=... level=WARN fiber=#0 message=message3
+   * ```
    *
    * @since 2.0.0
    * @category utils
    */
   (self: LogLevel): <A, E, R>(use: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
-   * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
-   * to the previous `LogLevel` after the `Effect` workflow completes.
+   * Temporarily sets a `LogLevel` for an `Effect` workflow.
+   *
+   * **Details**
+   *
+   * This function allows you to apply a specific `LogLevel` locally to an
+   * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its
+   * previous state.
+   *
+   * **When to Use**
+   *
+   * This is particularly useful when you want to adjust the verbosity of logging
+   * for specific parts of your program without affecting the global log level.
+   *
+   * @example
+   * ```ts
+   * import { Effect, LogLevel } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   yield* Effect.log("message1")
+   *   yield* Effect.gen(function*() {
+   *     yield* Effect.log("message2")
+   *     yield* Effect.log("message3")
+   *   }).pipe(LogLevel.locally(LogLevel.Warning))
+   * })
+   *
+   * // Effect.runFork(program)
+   * // timestamp=... level=INFO fiber=#0 message=message1
+   * // timestamp=... level=WARN fiber=#0 message=message2
+   * // timestamp=... level=WARN fiber=#0 message=message3
+   * ```
    *
    * @since 2.0.0
    * @category utils

package/src/ParseResult.ts

@@ -809,11 +809,11 @@ interface Parser {
 }
 
 const decodeMemoMap = globalValue(
-  Symbol.for("effect/Schema/Parser/decodeMemoMap"),
+  Symbol.for("effect/ParseResult/decodeMemoMap"),
   () => new WeakMap<AST.AST, Parser>()
 )
 const encodeMemoMap = globalValue(
-  Symbol.for("effect/Schema/Parser/encodeMemoMap"),
+  Symbol.for("effect/ParseResult/encodeMemoMap"),
   () => new WeakMap<AST.AST, Parser>()
 )
 
@@ -1419,9 +1419,10 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
     case "Union": {
       const searchTree = getSearchTree(ast.types, isDecoding)
       const ownKeys = util_.ownKeys(searchTree.keys)
-      const len = ownKeys.length
+      const ownKeysLen = ownKeys.length
+      const astTypesLen = ast.types.length
       const map = new Map<any, Parser>()
-      for (let i = 0; i < ast.types.length; i++) {
+      for (let i = 0; i < astTypesLen; i++) {
         map.set(ast.types[i], goMemo(ast.types[i], isDecoding))
       }
       const concurrency = getConcurrency(ast) ?? 1
@@ -1430,9 +1431,9 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         const es: Array<[number, ParseIssue]> = []
         let stepKey = 0
         let candidates: Array<AST.AST> = []
-        if (len > 0) {
+        if (ownKeysLen > 0) {
           if (Predicate.isRecordOrArray(input)) {
-            for (let i = 0; i < len; i++) {
+            for (let i = 0; i < ownKeysLen; i++) {
               const name = ownKeys[i]
               const buckets = searchTree.keys[name].buckets
               // for each property that should contain a literal, check if the input contains that property
@@ -1443,33 +1444,33 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                   // retrive the minimal set of candidates for decoding
                   candidates = candidates.concat(buckets[literal])
                 } else {
-                  const literals = AST.Union.make(searchTree.keys[name].literals)
+                  const { candidates, literals } = searchTree.keys[name]
+                  const literalsUnion = AST.Union.make(literals)
+                  const errorAst = candidates.length === astTypesLen
+                    ? new AST.TypeLiteral([new AST.PropertySignature(name, literalsUnion, false, true)], [])
+                    : AST.Union.make(candidates)
                   es.push([
                     stepKey++,
-                    new Composite(
-                      new AST.TypeLiteral([
-                        new AST.PropertySignature(name, literals, false, true)
-                      ], []),
-                      input,
-                      new Pointer(name, input, new Type(literals, input[name]))
-                    )
+                    new Composite(errorAst, input, new Pointer(name, input, new Type(literalsUnion, input[name])))
                   ])
                 }
               } else {
-                const literals = AST.Union.make(searchTree.keys[name].literals)
-                const fakeps = new AST.PropertySignature(name, literals, false, true)
+                const { candidates, literals } = searchTree.keys[name]
+                const fakePropertySignature = new AST.PropertySignature(name, AST.Union.make(literals), false, true)
+                const errorAst = candidates.length === astTypesLen
+                  ? new AST.TypeLiteral([fakePropertySignature], [])
+                  : AST.Union.make(candidates)
                 es.push([
                   stepKey++,
-                  new Composite(
-                    new AST.TypeLiteral([fakeps], []),
-                    input,
-                    new Pointer(name, input, new Missing(fakeps))
-                  )
+                  new Composite(errorAst, input, new Pointer(name, input, new Missing(fakePropertySignature)))
                 ])
               }
             }
           } else {
-            es.push([stepKey++, new Type(ast, input)])
+            const errorAst = searchTree.candidates.length === astTypesLen
+              ? ast
+              : AST.Union.make(searchTree.candidates)
+            es.push([stepKey++, new Type(errorAst, input)])
           }
         }
         if (searchTree.otherwise.length > 0) {
@@ -1608,16 +1609,19 @@ export const getLiterals = (
 }
 
 /**
- * The purpose of the algorithm is to narrow down the pool of possible candidates for decoding as much as possible.
+ * The purpose of the algorithm is to narrow down the pool of possible
+ * candidates for decoding as much as possible.
  *
  * This function separates the schemas into two groups, `keys` and `otherwise`:
  *
  * - `keys`: the schema has at least one property with a literal value
  * - `otherwise`: the schema has no properties with a literal value
  *
- * If a schema has at least one property with a literal value, so it ends up in `keys`, first a namespace is created for
- * the name of the property containing the literal, and then within this namespace a "bucket" is created for the literal
- * value in which to store all the schemas that have the same property and literal value.
+ * If a schema has at least one property with a literal value, so it ends up in
+ * `keys`, first a namespace is created for the name of the property containing
+ * the literal, and then within this namespace a "bucket" is created for the
+ * literal value in which to store all the schemas that have the same property
+ * and literal value.
  *
  * @internal
  */
@@ -1629,25 +1633,30 @@ export const getSearchTree = (
     readonly [key: PropertyKey]: {
       buckets: { [literal: string]: ReadonlyArray<AST.AST> }
       literals: ReadonlyArray<AST.Literal> // this is for error messages
+      candidates: ReadonlyArray<AST.AST>
     }
   }
   otherwise: ReadonlyArray<AST.AST>
+  candidates: ReadonlyArray<AST.AST>
 } => {
   const keys: {
     [key: PropertyKey]: {
       buckets: { [literal: string]: Array<AST.AST> }
       literals: Array<AST.Literal>
+      candidates: Array<AST.AST>
     }
   } = {}
   const otherwise: Array<AST.AST> = []
+  const candidates: Array<AST.AST> = []
   for (let i = 0; i < members.length; i++) {
     const member = members[i]
     const tags = getLiterals(member, isDecoding)
     if (tags.length > 0) {
+      candidates.push(member)
       for (let j = 0; j < tags.length; j++) {
         const [key, literal] = tags[j]
         const hash = String(literal.literal)
-        keys[key] = keys[key] || { buckets: {}, literals: [] }
+        keys[key] = keys[key] || { buckets: {}, literals: [], candidates: [] }
         const buckets = keys[key].buckets
         if (Object.prototype.hasOwnProperty.call(buckets, hash)) {
           if (j < tags.length - 1) {
@@ -1655,9 +1664,11 @@ export const getSearchTree = (
           }
           buckets[hash].push(member)
           keys[key].literals.push(literal)
+          keys[key].candidates.push(member)
         } else {
           buckets[hash] = [member]
           keys[key].literals.push(literal)
+          keys[key].candidates.push(member)
           break
         }
       }
@@ -1665,7 +1676,7 @@ export const getSearchTree = (
       otherwise.push(member)
     }
   }
-  return { keys, otherwise }
+  return { keys, otherwise, candidates }
 }
 
 const dropRightRefinement = (ast: AST.AST): AST.AST => AST.isRefinement(ast) ? dropRightRefinement(ast.from) : ast
@@ -1983,12 +1994,25 @@ const formatTree = (
 }
 
 /**
+ * Represents an issue returned by the {@link ArrayFormatter} formatter.
+ *
  * @category model
  * @since 3.10.0
  */
 export interface ArrayFormatterIssue {
+  /**
+   * The tag identifying the type of parse issue.
+   */
   readonly _tag: ParseIssue["_tag"]
+
+  /**
+   * The path to the property where the issue occurred.
+   */
   readonly path: ReadonlyArray<PropertyKey>
+
+  /**
+   * A descriptive message explaining the issue.
+   */
   readonly message: string
 }