effect 2.0.0-next.60 → 2.0.0-next.62

package/src/Match.ts

@@ -613,27 +613,27 @@ export declare namespace Types {
   type SafeRefinementP<A> = A extends never ? never
     : A extends SafeRefinement<infer S, infer _> ? S
     : A extends Function ? A
-    : A extends Record<string, any> ? DrainOuterGeneric<{ [K in keyof A]: SafeRefinementP<A[K]> }>
+    : A extends Record<string, any> ? { [K in keyof A]: SafeRefinementP<A[K]> }
     : A
 
   type SafeRefinementR<A> = A extends never ? never
     : A extends SafeRefinement<infer _, infer R> ? R
     : A extends Function ? A
-    : A extends Record<string, any> ? DrainOuterGeneric<{ [K in keyof A]: SafeRefinementR<A[K]> }>
+    : A extends Record<string, any> ? { [K in keyof A]: SafeRefinementR<A[K]> }
     : A
 
   type ResolvePred<A> = A extends never ? never
     : A extends Predicate.Refinement<any, infer P> ? P
     : A extends Predicate.Predicate<infer P> ? P
     : A extends SafeRefinement<any> ? A
-    : A extends Record<string, any> ? DrainOuterGeneric<{ [K in keyof A]: ResolvePred<A[K]> }>
+    : A extends Record<string, any> ? { [K in keyof A]: ResolvePred<A[K]> }
     : A
 
   type ToSafeRefinement<A> = A extends never ? never
     : A extends Predicate.Refinement<any, infer P> ? SafeRefinement<P, P>
     : A extends Predicate.Predicate<infer P> ? SafeRefinement<P, never>
     : A extends SafeRefinement<any> ? A
-    : A extends Record<string, any> ? DrainOuterGeneric<{ [K in keyof A]: ToSafeRefinement<A[K]> }>
+    : A extends Record<string, any> ? { [K in keyof A]: ToSafeRefinement<A[K]> }
     : NonLiteralsTo<A, never>
 
   type NonLiteralsTo<A, T> = [A] extends [string | number | boolean | bigint] ? [string] extends [A] ? T
@@ -643,16 +643,12 @@ export declare namespace Types {
     : A
     : A
 
-  type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never
-
   /**
    * @since 1.0.0
    */
   export type PatternBase<A> = A extends ReadonlyArray<infer _T> ? ReadonlyArray<any> | PatternPrimitive<A>
     : A extends Record<string, any> ? Partial<
-        DrainOuterGeneric<
-          { [K in keyof A]: PatternPrimitive<A[K] & {}> | PatternBase<A[K] & {}> }
-        >
+        { [K in keyof A]: PatternPrimitive<A[K] & {}> | PatternBase<A[K] & {}> }
       >
     : never
 
@@ -718,33 +714,6 @@ export declare namespace Types {
   export type ExtractMatch<I, P> = [ExtractAndNarrow<I, P>] extends [infer EI] ? EI
     : never
 
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
-  type IntersectOf<U extends unknown> = (
-    U extends unknown ? (k: U) => void : never
-  ) extends (k: infer I) => void ? I
-    : never
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
-  type Last<U extends any> = IntersectOf<
-    U extends unknown ? (x: U) => void : never
-  > extends (x: infer P) => void ? P
-    : never
-
-  type _ListOf<U, LN extends Array<any> = [], LastU = Last<U>> = {
-    0: _ListOf<Exclude<U, LastU>, [LastU, ...LN]>
-    1: LN
-  }[[U] extends [never] ? 1 : 0]
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
-  type ListOf<U extends any> = _ListOf<U> extends infer X ? X extends Array<any> ? X
-    : []
-    : never
-
-  type IsUnion<T, U extends T = T> = (
-    T extends any ? (U extends T ? false : true) : never
-  ) extends false ? false
-    : true
-
   type Replace<A, B> = A extends Function ? A
     : A extends Record<string | number, any> ? { [K in keyof A]: K extends keyof B ? Replace<A[K], B[K]> : A[K] }
     : [B] extends [A] ? B
@@ -767,46 +736,39 @@ export declare namespace Types {
 
   type Simplify<A> = { [K in keyof A]: A[K] } & {}
 
-  type ExtractAndNarrow<I, P> =
+  type ExtractAndNarrow<Input, P> =
     // unknown is a wildcard pattern
-    unknown extends P ? I
-      : IsUnion<I> extends true ? ListOf<I> extends infer L ? L extends Array<any> ? Exclude<
-              DrainOuterGeneric<
-                { [K in keyof L]: ExtractAndNarrow<L[K], P> }
-              >[number],
-              Fail
-            >
-          : never
-        : never
-      : I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? DrainOuterGeneric<
-            {
-              readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]>
-                : I[K]
-            }
-          > extends infer R ? Fail extends R[keyof R] ? never
-            : R
-          : never
-        : never
-      : IsPlainObject<I> extends true ? string extends keyof I ? I extends P ? I
-          : never
-        : symbol extends keyof I ? I extends P ? I
-          : never
-        : Simplify<
-          DrainOuterGeneric<
-            {
-              [RK in Extract<keyof I, keyof P>]-?: ExtractAndNarrow<I[RK], P[RK]>
-            }
-          > & Omit<I, keyof P>
-        > extends infer R ? [keyof P] extends [keyof RemoveFails<R>] ? R
-          : never
-        : never
-      : MaybeReplace<I, P> extends infer R ? [I] extends [R] ? I
-        : R
-      : never
-
-  type RemoveFails<A> = {
-    [K in keyof A & {}]: A[K] extends Fail ? never : K
-  }[keyof A] extends infer K ? [K] extends [keyof A] ? { [RK in K]: A[RK] }
+    unknown extends P ? Input
+      : Input extends infer I ? Exclude<
+          I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? {
+                readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]>
+                  : I[K]
+              } extends infer R ? Fail extends R[keyof R] ? never
+                : R
+              : never
+            : never
+            : IsPlainObject<I> extends true ? string extends keyof I ? I extends P ? I
+                : never
+              : symbol extends keyof I ? I extends P ? I
+                : never
+              : Simplify<
+                & { [RK in Extract<keyof I, keyof P>]-?: ExtractAndNarrow<I[RK], P[RK]> }
+                & Omit<I, keyof P>
+              > extends infer R ? [keyof P] extends [keyof RemoveFails<R>] ? R
+                : never
+              : never
+            : MaybeReplace<I, P> extends infer R ? [I] extends [R] ? I
+              : R
+            : never,
+          Fail
+        > :
+      never
+
+  type RemoveFails<A> = NonFailKeys<A> extends infer K ? [K] extends [keyof A] ? { [RK in K]: A[RK] }
     : {}
     : {}
+
+  type NonFailKeys<A> = keyof A & {} extends infer K ? K extends keyof A ? A[K] extends Fail ? never : K
+    : never :
+    never
 }

package/src/ReadonlyRecord.ts

@@ -117,6 +117,34 @@ export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Recor
   identity
 )
 
+/**
+ * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.
+ *
+ * @param items - An iterable containing elements.
+ * @param f - A function that extracts the key for each element.
+ *
+ * @example
+ * import { fromIterableBy } from "effect/ReadonlyRecord"
+ *
+ * const users = [
+ *   { id: "2", name: "name2" },
+ *   { id: "1", name: "name1" }
+ * ]
+ *
+ * assert.deepStrictEqual(
+ *   fromIterableBy(users, user => user.id),
+ *   {
+ *     "2": { id: "2", name: "name2" },
+ *     "1": { id: "1", name: "name1" }
+ *   }
+ * )
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const fromIterableBy = <A>(items: Iterable<A>, f: (a: A) => string): Record<string, A> =>
+  fromIterableWith(items, (a) => [f(a), a])
+
 /**
  * Builds a record from an iterable of key-value pairs.
  *

package/src/internal/configProvider.ts

@@ -12,7 +12,7 @@ import * as HashSet from "../HashSet.js"
 import * as number from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as RA from "../ReadonlyArray.js"
+import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
 import * as pathPatch from "./configProvider/pathPatch.js"
@@ -20,6 +20,8 @@ import * as core from "./core.js"
 import * as OpCodes from "./opCodes/config.js"
 import * as StringUtils from "./string-utils.js"
 
+type KeyComponent = ConfigProvider.ConfigProvider.KeyComponent
+
 const concat = <A, B>(l: ReadonlyArray<A>, r: ReadonlyArray<B>): ReadonlyArray<A | B> => [...l, ...r]
 
 /** @internal */
@@ -81,12 +83,12 @@ export const makeFlat = (
 export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvider.ConfigProvider =>
   make({
     load: (config) =>
-      core.flatMap(fromFlatLoop(flat, RA.empty(), config, false), (chunk) =>
-        Option.match(RA.head(chunk), {
+      core.flatMap(fromFlatLoop(flat, ReadonlyArray.empty(), config, false), (chunk) =>
+        Option.match(ReadonlyArray.head(chunk), {
           onNone: () =>
             core.fail(
               configError.MissingData(
-                RA.empty(),
+                ReadonlyArray.empty(),
                 `Expected a single value having structure: ${config}`
               )
             ),
@@ -100,7 +102,7 @@ export const fromEnv = (
   config: Partial<ConfigProvider.ConfigProvider.FromEnvConfig> = {}
 ): ConfigProvider.ConfigProvider => {
   const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, config)
-  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, RA.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, ReadonlyArray.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
 
   const getEnv = () =>
@@ -130,7 +132,7 @@ export const fromEnv = (
       const keyPaths = Array.from(keys).map((value) => unmakePathString(value.toUpperCase()))
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, RA.unsafeGet(i))
+          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -150,7 +152,7 @@ export const fromMap = (
   config: Partial<ConfigProvider.ConfigProvider.FromMapConfig> = {}
 ): ConfigProvider.ConfigProvider => {
   const { pathDelim, seqDelim } = Object.assign({ seqDelim: ",", pathDelim: "." }, config)
-  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, RA.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, ReadonlyArray.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
   const mapWithIndexSplit = splitIndexInKeys(
     map,
@@ -179,7 +181,7 @@ export const fromMap = (
       const keyPaths = Array.from(mapWithIndexSplit.keys()).map(unmakePathString)
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, RA.unsafeGet(i))
+          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -199,14 +201,14 @@ const extend = <A, B>(
   left: ReadonlyArray<A>,
   right: ReadonlyArray<B>
 ): [ReadonlyArray<A>, ReadonlyArray<B>] => {
-  const leftPad = RA.unfold(
+  const leftPad = ReadonlyArray.unfold(
     left.length,
     (index) =>
       index >= right.length ?
         Option.none() :
         Option.some([leftDef(index), index + 1])
   )
-  const rightPad = RA.unfold(
+  const rightPad = ReadonlyArray.unfold(
     right.length,
     (index) =>
       index >= left.length ?
@@ -240,7 +242,7 @@ const fromFlatLoop = <A>(
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(RA.of(op.value)) as Effect.Effect<
+      return core.succeed(ReadonlyArray.of(op.value)) as Effect.Effect<
         never,
         ConfigError.ConfigError,
         ReadonlyArray<A>
@@ -298,7 +300,7 @@ const fromFlatLoop = <A>(
       return core.suspend(() =>
         fromFlatLoop(
           flat,
-          concat(prefix, RA.of(op.name)),
+          concat(prefix, ReadonlyArray.of(op.name)),
           op.config,
           split
         )
@@ -312,7 +314,7 @@ const fromFlatLoop = <A>(
             flat.load(prefix, op, split),
             core.flatMap((values) => {
               if (values.length === 0) {
-                const name = pipe(RA.last(prefix), Option.getOrElse(() => "<n/a>"))
+                const name = pipe(ReadonlyArray.last(prefix), Option.getOrElse(() => "<n/a>"))
                 return core.fail(configError.MissingData([], `Expected ${op.description} with name ${name}`))
               }
               return core.succeed(values)
@@ -331,20 +333,20 @@ const fromFlatLoop = <A>(
             core.flatMap((indices) => {
               if (indices.length === 0) {
                 return core.suspend(() =>
-                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), RA.of)
+                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), ReadonlyArray.of)
                 ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
               }
               return pipe(
                 core.forEachSequential(
                   indices,
-                  (index) => fromFlatLoop(flat, RA.append(prefix, `[${index}]`), op.config, true)
+                  (index) => fromFlatLoop(flat, ReadonlyArray.append(prefix, `[${index}]`), op.config, true)
                 ),
                 core.map((chunkChunk) => {
-                  const flattened = RA.flatten(chunkChunk)
+                  const flattened = ReadonlyArray.flatten(chunkChunk)
                   if (flattened.length === 0) {
-                    return RA.of(RA.empty<A>())
+                    return ReadonlyArray.of(ReadonlyArray.empty<A>())
                   }
-                  return RA.of(flattened)
+                  return ReadonlyArray.of(flattened)
                 })
               ) as unknown as Effect.Effect<never, ConfigError.ConfigError, ReadonlyArray<A>>
             })
@@ -365,19 +367,21 @@ const fromFlatLoop = <A>(
                   core.forEachSequential((key) =>
                     fromFlatLoop(
                       flat,
-                      concat(prefix, RA.of(key)),
+                      concat(prefix, ReadonlyArray.of(key)),
                       op.valueConfig,
                       split
                     )
                   ),
                   core.map((values) => {
                     if (values.length === 0) {
-                      return RA.of(HashMap.empty())
+                      return ReadonlyArray.of(HashMap.empty())
                     }
                     const matrix = values.map((x) => Array.from(x))
                     return pipe(
                       transpose(matrix),
-                      RA.map((values) => HashMap.fromIterable(RA.zip(RA.fromIterable(keys), values)))
+                      ReadonlyArray.map((values) =>
+                        HashMap.fromIterable(ReadonlyArray.zip(ReadonlyArray.fromIterable(keys), values))
+                      )
                     )
                   })
                 )
@@ -407,17 +411,17 @@ const fromFlatLoop = <A>(
                   return core.fail(right.left)
                 }
                 if (Either.isRight(left) && Either.isRight(right)) {
-                  const path = pipe(prefix, RA.join("."))
+                  const path = pipe(prefix, ReadonlyArray.join("."))
                   const fail = fromFlatLoopFail(prefix, path)
                   const [lefts, rights] = extend(
                     fail,
                     fail,
-                    pipe(left.right, RA.map(Either.right)),
-                    pipe(right.right, RA.map(Either.right))
+                    pipe(left.right, ReadonlyArray.map(Either.right)),
+                    pipe(right.right, ReadonlyArray.map(Either.right))
                   )
                   return pipe(
                     lefts,
-                    RA.zip(rights),
+                    ReadonlyArray.zip(rights),
                     core.forEachSequential(([left, right]) =>
                       pipe(
                         core.zip(left, right),
@@ -590,8 +594,8 @@ export const within = dual<
     f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
   ) => ConfigProvider.ConfigProvider
 >(3, (self, path, f) => {
-  const unnest = RA.reduce(path, self, (provider, name) => unnested(provider, name))
-  const nest = RA.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
+  const unnest = ReadonlyArray.reduce(path, self, (provider, name) => unnested(provider, name))
+  const nest = ReadonlyArray.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
   return orElse(nest, () => self)
 })
 
@@ -612,7 +616,7 @@ const parsePrimitive = <A>(
       primitive.parse(text),
       core.mapBoth({
         onFailure: configError.prefixed(path),
-        onSuccess: RA.of
+        onSuccess: ReadonlyArray.of
       })
     )
   }
@@ -635,8 +639,8 @@ const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<neve
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({
-      onFailure: () => RA.empty<number>(),
-      onSuccess: RA.sort(number.Order)
+      onFailure: () => ReadonlyArray.empty<number>(),
+      onSuccess: ReadonlyArray.sort(number.Order)
     }),
     core.either,
     core.map(Either.merge)
@@ -668,10 +672,10 @@ const splitIndexInKeys = (
   for (const [pathString, value] of map) {
     const keyWithIndex = pipe(
       unmakePathString(pathString),
-      RA.flatMap((key) =>
+      ReadonlyArray.flatMap((key) =>
         Option.match(splitIndexFrom(key), {
-          onNone: () => RA.of(key),
-          onSome: ([key, index]) => RA.make(key, `[${index}]`)
+          onNone: () => ReadonlyArray.of(key),
+          onSome: ([key, index]) => ReadonlyArray.make(key, `[${index}]`)
         })
       )
     )
@@ -705,3 +709,99 @@ const parseInteger = (str: string): Option.Option<number> => {
     Option.none() :
     Option.some(parsedIndex)
 }
+
+const keyName = (name: string): KeyComponent => ({
+  _tag: "KeyName",
+  name
+})
+
+const keyIndex = (index: number): KeyComponent => ({
+  _tag: "KeyIndex",
+  index
+})
+
+interface JsonMap {
+  [member: string]: string | number | boolean | null | JsonArray | JsonMap
+}
+interface JsonArray extends Array<string | number | boolean | null | JsonArray | JsonMap> {}
+
+/** @internal */
+export const fromJson = (json: unknown): ConfigProvider.ConfigProvider => {
+  const hiddenDelimiter = "\ufeff"
+  const indexedEntries = ReadonlyArray.map(
+    getIndexedEntries(json as JsonMap),
+    ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
+  )
+  return fromMap(new Map(indexedEntries), {
+    pathDelim: hiddenDelimiter,
+    seqDelim: hiddenDelimiter
+  })
+}
+
+const configPathToString = (path: ReadonlyArray<KeyComponent>): ReadonlyArray<string> => {
+  const output: Array<string> = []
+  let i = 0
+  while (i < path.length) {
+    const component = path[i]
+    if (component._tag === "KeyName") {
+      if (i + 1 < path.length) {
+        const nextComponent = path[i + 1]
+        if (nextComponent._tag === "KeyIndex") {
+          output.push(`${component.name}[${nextComponent.index}]`)
+          i += 2
+        } else {
+          output.push(component.name)
+          i += 1
+        }
+      } else {
+        output.push(component.name)
+        i += 1
+      }
+    }
+  }
+  return output
+}
+
+const getIndexedEntries = (
+  config: JsonMap
+): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
+  const loopAny = (
+    path: ReadonlyArray<KeyComponent>,
+    value: string | number | boolean | JsonMap | JsonArray | null
+  ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
+    if (typeof value === "string") {
+      return ReadonlyArray.make([path, value] as [ReadonlyArray<KeyComponent>, string])
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return ReadonlyArray.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
+    }
+    if (Array.isArray(value)) {
+      return loopArray(path, value)
+    }
+    if (typeof value === "object" && value !== null) {
+      return loopObject(path, value)
+    }
+    return ReadonlyArray.empty<[ReadonlyArray<KeyComponent>, string]>()
+  }
+  const loopArray = (
+    path: ReadonlyArray<KeyComponent>,
+    values: JsonArray
+  ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
+    ReadonlyArray.match(values, {
+      onEmpty: () => ReadonlyArray.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
+      onNonEmpty: ReadonlyArray.flatMap((value, index) => loopAny(ReadonlyArray.append(path, keyIndex(index)), value))
+    })
+  const loopObject = (
+    path: ReadonlyArray<KeyComponent>,
+    value: JsonMap
+  ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
+    Object.entries(value).flatMap(([key, value]) => {
+      const newPath = ReadonlyArray.append(path, keyName(key))
+      const result = loopAny(newPath, value)
+      if (ReadonlyArray.isEmptyReadonlyArray(result)) {
+        return ReadonlyArray.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
+      }
+      return result
+    })
+  return loopObject(ReadonlyArray.empty(), config)
+}