effect 3.11.8 → 3.11.9

package/src/Option.ts

@@ -120,7 +120,7 @@ export const none = <A = never>(): Option<A> => option.none
 export const some: <A>(value: A) => Option<A> = option.some
 
 /**
- * Tests if a value is a `Option`.
+ * Checks if a given value is an `Option` value.
  *
  * @param input - The value to check.
  *

package/src/Schema.ts

@@ -793,10 +793,38 @@ export interface TemplateLiteralParser<Params extends array_.NonEmptyReadonlyArr
   readonly params: Params
 }
 
-const literalValueCoercions: Record<string, ((v: AST.LiteralValue) => AST.LiteralValue)> = {
-  bigint: (v: AST.LiteralValue) => Predicate.isString(v) ? BigInt(v) : v,
-  boolean: (v: AST.LiteralValue) => v === "true" ? true : v === "false" ? false : v,
-  null: (v: AST.LiteralValue) => v === "null" ? null : v
+function getTemplateLiteralParserCoercedElement(encoded: Schema.Any, schema: Schema.Any): Schema.Any | undefined {
+  const ast = encoded.ast
+  switch (ast._tag) {
+    case "Literal": {
+      const literal = ast.literal
+      if (!Predicate.isString(literal)) {
+        const s = String(literal)
+        return transform(Literal(s), schema, {
+          strict: true,
+          decode: () => literal,
+          encode: () => s
+        })
+      }
+      break
+    }
+    case "NumberKeyword":
+      return compose(NumberFromString, schema)
+    case "Union": {
+      const members: Array<Schema.Any> = []
+      let hasCoercions = false
+      for (const member of ast.types) {
+        const schema = make(member)
+        const encoded = encodedSchema(schema)
+        const coerced = getTemplateLiteralParserCoercedElement(encoded, schema)
+        if (coerced) {
+          hasCoercions = true
+        }
+        members.push(coerced ?? schema)
+      }
+      return hasCoercions ? compose(Union(...members), schema) : schema
+    }
+  }
 }
 
 /**
@@ -807,49 +835,36 @@ export const TemplateLiteralParser = <Params extends array_.NonEmptyReadonlyArra
   ...params: Params
 ): TemplateLiteralParser<Params> => {
   const encodedSchemas: Array<Schema.Any> = []
-  const typeSchemas: Array<Schema.Any> = []
-  const coercions: Record<number, ((v: AST.LiteralValue) => AST.LiteralValue) | undefined> = {}
+  const elements: Array<Schema.Any> = []
+  const schemas: Array<Schema.Any> = []
+  let coerced = false
   for (let i = 0; i < params.length; i++) {
     const param = params[i]
-    if (isSchema(param)) {
-      const encoded = encodedSchema(param)
-      if (AST.isNumberKeyword(encoded.ast)) {
-        coercions[i] = Number
-      }
-      encodedSchemas.push(encoded)
-      typeSchemas.push(param)
+    const schema = isSchema(param) ? param : Literal(param)
+    schemas.push(schema)
+    const encoded = encodedSchema(schema)
+    encodedSchemas.push(encoded)
+    const element = getTemplateLiteralParserCoercedElement(encoded, schema)
+    if (element) {
+      elements.push(element)
+      coerced = true
     } else {
-      const schema = Literal(param)
-      if (Predicate.isNumber(param)) {
-        coercions[i] = Number
-      } else if (Predicate.isBigInt(param)) {
-        coercions[i] = literalValueCoercions.bigint
-      } else if (Predicate.isBoolean(param)) {
-        coercions[i] = literalValueCoercions.boolean
-      } else if (Predicate.isNull(param)) {
-        coercions[i] = literalValueCoercions.null
-      }
-      encodedSchemas.push(schema)
-      typeSchemas.push(schema)
+      elements.push(schema)
     }
   }
   const from = TemplateLiteral(...encodedSchemas as any)
   const re = AST.getTemplateLiteralCapturingRegExp(from.ast as AST.TemplateLiteral)
-  return class TemplateLiteralParserClass extends transformOrFail(from, Tuple(...typeSchemas), {
+  let to = Tuple(...elements)
+  if (coerced) {
+    to = to.annotations({ [AST.AutoTitleAnnotationId]: format(Tuple(...schemas)) })
+  }
+  return class TemplateLiteralParserClass extends transformOrFail(from, to, {
     strict: false,
     decode: (s, _, ast) => {
       const match = re.exec(s)
-      if (match) {
-        const out: Array<AST.LiteralValue> = match.slice(1, params.length + 1)
-        for (let i = 0; i < out.length; i++) {
-          const coerce = coercions[i]
-          if (coerce) {
-            out[i] = coerce(out[i])
-          }
-        }
-        return ParseResult.succeed(out)
-      }
-      return ParseResult.fail(new ParseResult.Type(ast, s, `${re.source}: no match for ${JSON.stringify(s)}`))
+      return match
+        ? ParseResult.succeed(match.slice(1, params.length + 1))
+        : ParseResult.fail(new ParseResult.Type(ast, s, `${re.source}: no match for ${JSON.stringify(s)}`))
     },
     encode: (tuple) => ParseResult.succeed(tuple.join(""))
   }) {
@@ -9996,12 +10011,12 @@ export class BooleanFromString extends transform(
  * @category Config validations
  * @since 3.10.0
  */
-export const Config = <A>(name: string, schema: Schema<A, string>): config_.Config<A> => {
-  const decodeEither_ = decodeEither(schema)
+export const Config = <A, I extends string>(name: string, schema: Schema<A, I>): config_.Config<A> => {
+  const decodeUnknownEither = ParseResult.decodeUnknownEither(schema)
   return config_.string(name).pipe(
-    config_.mapOrFail((a) =>
-      decodeEither_(a).pipe(
-        either_.mapLeft((error) => configError_.InvalidData([], ParseResult.TreeFormatter.formatErrorSync(error)))
+    config_.mapOrFail((s) =>
+      decodeUnknownEither(s).pipe(
+        either_.mapLeft((error) => configError_.InvalidData([], ParseResult.TreeFormatter.formatIssueSync(error)))
       )
     )
   )

package/src/SchemaAST.ts

@@ -1096,7 +1096,7 @@ export class Enums implements Annotated {
  */
 export const isEnums: (ast: AST) => ast is Enums = createASTGuard("Enums")
 
-type TemplateLiteralSpanBaseType = StringKeyword | NumberKeyword | Literal
+type TemplateLiteralSpanBaseType = StringKeyword | NumberKeyword | Literal | TemplateLiteral
 
 type TemplateLiteralSpanType = TemplateLiteralSpanBaseType | Union<TemplateLiteralSpanType>
 
@@ -1105,6 +1105,7 @@ const isTemplateLiteralSpanType = (ast: AST): ast is TemplateLiteralSpanType =>
     case "Literal":
     case "NumberKeyword":
     case "StringKeyword":
+    case "TemplateLiteral":
       return true
     case "Union":
       return ast.types.every(isTemplateLiteralSpanType)
@@ -1120,6 +1121,8 @@ const templateLiteralSpanUnionTypeToString = (type: TemplateLiteralSpanType): st
       return "string"
     case "NumberKeyword":
       return "number"
+    case "TemplateLiteral":
+      return String(type)
     case "Union":
       return type.types.map(templateLiteralSpanUnionTypeToString).join(" | ")
   }
@@ -1133,6 +1136,8 @@ const templateLiteralSpanTypeToString = (type: TemplateLiteralSpanType): string
       return "${string}"
     case "NumberKeyword":
       return "${number}"
+    case "TemplateLiteral":
+      return "${" + String(type) + "}"
     case "Union":
       return "${" + type.types.map(templateLiteralSpanUnionTypeToString).join(" | ") + "}"
   }
@@ -2093,72 +2098,75 @@ export const keyof = (ast: AST): AST => Union.unify(_keyof(ast))
 const STRING_KEYWORD_PATTERN = ".*"
 const NUMBER_KEYWORD_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?"
 
-const getTemplateLiteralPattern = (type: TemplateLiteralSpanType): string => {
+const getTemplateLiteralSpanTypePattern = (type: TemplateLiteralSpanType, capture: boolean): string => {
   switch (type._tag) {
+    case "Literal":
+      return regexp.escape(String(type.literal))
     case "StringKeyword":
       return STRING_KEYWORD_PATTERN
     case "NumberKeyword":
       return NUMBER_KEYWORD_PATTERN
-    case "Literal":
-      return regexp.escape(String(type.literal))
+    case "TemplateLiteral":
+      return getTemplateLiteralPattern(type, capture, false)
     case "Union":
-      return type.types.map(getTemplateLiteralPattern).join("|")
+      return type.types.map((type) => getTemplateLiteralSpanTypePattern(type, capture)).join("|")
   }
 }
 
-/**
- * @since 3.10.0
- */
-export const getTemplateLiteralRegExp = (ast: TemplateLiteral): RegExp => {
-  let pattern = `^`
+const handleTemplateLiteralSpanTypeParens = (
+  type: TemplateLiteralSpanType,
+  s: string,
+  capture: boolean,
+  top: boolean
+) => {
+  if (isUnion(type)) {
+    if (capture && !top) {
+      return `(?:${s})`
+    }
+  } else if (!capture || !top) {
+    return s
+  }
+  return `(${s})`
+}
+
+const getTemplateLiteralPattern = (ast: TemplateLiteral, capture: boolean, top: boolean): string => {
+  let pattern = ``
   if (ast.head !== "") {
-    pattern += regexp.escape(ast.head)
+    const head = regexp.escape(ast.head)
+    pattern += capture && top ? `(${head})` : head
   }
 
   for (const span of ast.spans) {
-    const p = getTemplateLiteralPattern(span.type)
-    pattern += isUnion(span.type) ? `(${p})` : p
+    const spanPattern = getTemplateLiteralSpanTypePattern(span.type, capture)
+    pattern += handleTemplateLiteralSpanTypeParens(span.type, spanPattern, capture, top)
     if (span.literal !== "") {
-      pattern += regexp.escape(span.literal)
+      const literal = regexp.escape(span.literal)
+      pattern += capture && top ? `(${literal})` : literal
     }
   }
 
-  pattern += "$"
-  return new RegExp(pattern)
-}
-
-const getTemplateLiteralCapturingPattern = (type: TemplateLiteralSpanType): string => {
-  switch (type._tag) {
-    case "StringKeyword":
-      return STRING_KEYWORD_PATTERN
-    case "NumberKeyword":
-      return NUMBER_KEYWORD_PATTERN
-    case "Literal":
-      return regexp.escape(String(type.literal))
-    case "Union":
-      return type.types.map(getTemplateLiteralCapturingPattern).join("|")
-  }
+  return pattern
 }
 
 /**
+ * Generates a regular expression from a `TemplateLiteral` AST node.
+ *
+ * @see {@link getTemplateLiteralCapturingRegExp} for a variant that captures the pattern.
+ *
  * @since 3.10.0
  */
-export const getTemplateLiteralCapturingRegExp = (ast: TemplateLiteral): RegExp => {
-  let pattern = `^`
-  if (ast.head !== "") {
-    pattern += `(${regexp.escape(ast.head)})`
-  }
-
-  for (const span of ast.spans) {
-    pattern += `(${getTemplateLiteralCapturingPattern(span.type)})`
-    if (span.literal !== "") {
-      pattern += `(${regexp.escape(span.literal)})`
-    }
-  }
+export const getTemplateLiteralRegExp = (ast: TemplateLiteral): RegExp =>
+  new RegExp(`^${getTemplateLiteralPattern(ast, false, true)}$`)
 
-  pattern += "$"
-  return new RegExp(pattern)
-}
+/**
+ * Generates a regular expression that captures the pattern defined by the given `TemplateLiteral` AST.
+ *
+ * @see {@link getTemplateLiteralRegExp} for a variant that does not capture the pattern.
+ *
+ * @since 3.10.0
+ */
+export const getTemplateLiteralCapturingRegExp = (ast: TemplateLiteral): RegExp =>
+  new RegExp(`^${getTemplateLiteralPattern(ast, true, true)}$`)
 
 /**
  * @since 3.10.0

package/src/internal/core-effect.ts

@@ -664,23 +664,23 @@ export const filterOrFail: {
 /* @internal */
 export const findFirst: {
   <A, E, R>(
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R> =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
       const next = iterator.next()
       if (!next.done) {
-        return findLoop(iterator, 0, f, next.value)
+        return findLoop(iterator, 0, predicate, next.value)
       }
       return core.succeed(Option.none())
     })
@@ -762,15 +762,18 @@ export const match: {
 /* @internal */
 export const every: {
   <A, E, R>(
-    f: (a: A, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<boolean, E, R>
-  <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>): Effect.Effect<boolean, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<boolean, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    f: (a: A, i: number) => Effect.Effect<boolean, E, R>
-  ): Effect.Effect<boolean, E, R> => core.suspend(() => forAllLoop(elements[Symbol.iterator](), 0, f))
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<boolean, E, R> => core.suspend(() => forAllLoop(elements[Symbol.iterator](), 0, predicate))
 )
 
 const forAllLoop = <A, E, R>(

package/src/internal/fiberRuntime.ts

@@ -1705,30 +1705,30 @@ const _existsParFound = Symbol.for("effect/Effect/existsPar/found")
 
 /* @internal */
 export const exists: {
-  <A, E, R>(f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }): (elements: Iterable<A>) => Effect.Effect<boolean, E, R>
-  <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }): Effect.Effect<boolean, E, R>
 } = dual(
   (args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]),
-  <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
   }) =>
     concurrency.matchSimple(
       options?.concurrency,
-      () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)),
+      () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, predicate)),
       () =>
         core.matchEffect(
           forEach(
             elements,
-            (a, i) => core.if_(f(a, i), { onTrue: () => core.fail(_existsParFound), onFalse: () => core.void }),
+            (a, i) => core.if_(predicate(a, i), { onTrue: () => core.fail(_existsParFound), onFalse: () => core.void }),
             options
           ),
           {
@@ -1757,7 +1757,7 @@ const existsLoop = <A, E, R>(
 /* @internal */
 export const filter = dual<
   <A, E, R>(
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -1765,7 +1765,7 @@ export const filter = dual<
       readonly concurrentFinalizers?: boolean | undefined
     }
   ) => (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>,
-  <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly negate?: boolean | undefined
@@ -1773,13 +1773,13 @@ export const filter = dual<
   }) => Effect.Effect<Array<A>, E, R>
 >(
   (args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]),
-  <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly negate?: boolean | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }) => {
-    const predicate = options?.negate ? (a: A, i: number) => core.map(f(a, i), Boolean.not) : f
+    const predicate_ = options?.negate ? (a: A, i: number) => core.map(predicate(a, i), Boolean.not) : predicate
     return concurrency.matchSimple(
       options?.concurrency,
       () =>
@@ -1788,7 +1788,7 @@ export const filter = dual<
             (effect, a, i) =>
               core.zipWith(
                 effect,
-                core.suspend(() => predicate(a, i)),
+                core.suspend(() => predicate_(a, i)),
                 (list, b) => b ? [a, ...list] : list
               ),
             core.sync(() => new Array<A>()) as Effect.Effect<Array<A>, E, R>
@@ -1798,7 +1798,7 @@ export const filter = dual<
         core.map(
           forEach(
             elements,
-            (a, i) => core.map(predicate(a, i), (b) => (b ? Option.some(a) : Option.none())),
+            (a, i) => core.map(predicate_(a, i), (b) => (b ? Option.some(a) : Option.none())),
             options
           ),
           RA.getSomes
@@ -2706,7 +2706,7 @@ const raceAllArbiter = <E, E1, A, A1>(
 export const reduceEffect = dual<
   <Z, E, R, Eff extends Effect.Effect<any, any, any>>(
     zero: Effect.Effect<Z, E, R>,
-    f: (acc: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
+    f: (z: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -2716,7 +2716,7 @@ export const reduceEffect = dual<
   <Eff extends Effect.Effect<any, any, any>, Z, E, R>(
     elements: Iterable<Eff>,
     zero: Effect.Effect<Z, E, R>,
-    f: (acc: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
+    f: (z: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -2726,7 +2726,7 @@ export const reduceEffect = dual<
 >((args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]), <A, E, R, Z>(
   elements: Iterable<Effect.Effect<A, E, R>>,
   zero: Effect.Effect<Z, E, R>,
-  f: (acc: NoInfer<Z>, a: NoInfer<A>, i: number) => Z,
+  f: (z: NoInfer<Z>, a: NoInfer<A>, i: number) => Z,
   options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined

package/src/internal/version.ts

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