effect 2.0.0-next.60 → 2.0.0-next.61

package/src/ConfigProvider.ts

@@ -104,6 +104,30 @@ export declare namespace ConfigProvider {
     readonly pathDelim: string
     readonly seqDelim: string
   }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type KeyComponent = KeyName | KeyIndex
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface KeyName {
+    readonly _tag: "KeyName"
+    readonly name: string
+  }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface KeyIndex {
+    readonly _tag: "KeyIndex"
+    readonly index: number
+  }
 }
 
 /**
@@ -163,6 +187,14 @@ export const fromEnv: (config?: ConfigProvider.FromEnvConfig) => ConfigProvider
  */
 export const fromFlat: (flat: ConfigProvider.Flat) => ConfigProvider = internal.fromFlat
 
+/**
+ * Constructs a new `ConfigProvider` from a JSON object.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromJson: (json: unknown) => ConfigProvider = internal.fromJson
+
 /**
  * Constructs a ConfigProvider using a map and the specified delimiter string,
  * which determines how to split the keys in the map into path segments.

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)
+}

package/src/internal/fiberRuntime.ts

@@ -80,9 +80,9 @@ export const fiberLifetimes = metric.tagged(
   metric.histogram(
     "effect_fiber_lifetimes",
     metricBoundaries.exponential({
-      start: 1.0,
-      factor: 1.3,
-      count: 100
+      start: 0.5,
+      factor: 2,
+      count: 35
     })
   ),
   "time_unit",
@@ -2225,7 +2225,7 @@ export const mergeAll = dual<
     readonly batching?: boolean | "inherit" | undefined
   }) => Effect.Effect<R, E, Z>
 >(
-  (args) => Predicate.isIterable(args[0]),
+  (args) => Predicate.isFunction(args[2]),
   <R, E, A, Z>(elements: Iterable<Effect.Effect<R, E, A>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined

package/src/internal/metric.ts

@@ -308,9 +308,9 @@ export const timer = (name: string, description?: string): Metric.Metric<
   MetricState.MetricState.Histogram
 > => {
   const boundaries = metricBoundaries.exponential({
-    start: 1,
+    start: 0.5,
     factor: 2,
-    count: 100
+    count: 35
   })
   const base = pipe(histogram(name, boundaries, description), tagged("time_unit", "milliseconds"))
   return mapInput(base, Duration.toMillis)

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.0.0-next.60"
+export const moduleVersion = "2.0.0-next.61"