effect 2.4.19 → 3.0.1

package/src/internal/configError.ts

@@ -1,9 +1,9 @@
+import * as RA from "../Array.js"
 import type * as Cause from "../Cause.js"
 import type * as ConfigError from "../ConfigError.js"
 import * as Either from "../Either.js"
 import { constFalse, constTrue, dual, pipe } from "../Function.js"
 import { hasProperty } from "../Predicate.js"
-import * as RA from "../ReadonlyArray.js"
 import * as OpCodes from "./opCodes/configError.js"
 
 /** @internal */
@@ -16,13 +16,14 @@ export const ConfigErrorTypeId: ConfigError.ConfigErrorTypeId = Symbol.for(
 
 /** @internal */
 export const proto = {
+  _tag: "ConfigError",
   [ConfigErrorTypeId]: ConfigErrorTypeId
 }
 
 /** @internal */
 export const And = (self: ConfigError.ConfigError, that: ConfigError.ConfigError): ConfigError.ConfigError => {
   const error = Object.create(proto)
-  error._tag = OpCodes.OP_AND
+  error._op = OpCodes.OP_AND
   error.left = self
   error.right = that
   Object.defineProperty(error, "toString", {
@@ -37,7 +38,7 @@ export const And = (self: ConfigError.ConfigError, that: ConfigError.ConfigError
 /** @internal */
 export const Or = (self: ConfigError.ConfigError, that: ConfigError.ConfigError): ConfigError.ConfigError => {
   const error = Object.create(proto)
-  error._tag = OpCodes.OP_OR
+  error._op = OpCodes.OP_OR
   error.left = self
   error.right = that
   Object.defineProperty(error, "toString", {
@@ -56,7 +57,7 @@ export const InvalidData = (
   options: ConfigError.Options = { pathDelim: "." }
 ): ConfigError.ConfigError => {
   const error = Object.create(proto)
-  error._tag = OpCodes.OP_INVALID_DATA
+  error._op = OpCodes.OP_INVALID_DATA
   error.path = path
   error.message = message
   Object.defineProperty(error, "toString", {
@@ -76,7 +77,7 @@ export const MissingData = (
   options: ConfigError.Options = { pathDelim: "." }
 ): ConfigError.ConfigError => {
   const error = Object.create(proto)
-  error._tag = OpCodes.OP_MISSING_DATA
+  error._op = OpCodes.OP_MISSING_DATA
   error.path = path
   error.message = message
   Object.defineProperty(error, "toString", {
@@ -97,7 +98,7 @@ export const SourceUnavailable = (
   options: ConfigError.Options = { pathDelim: "." }
 ): ConfigError.ConfigError => {
   const error = Object.create(proto)
-  error._tag = OpCodes.OP_SOURCE_UNAVAILABLE
+  error._op = OpCodes.OP_SOURCE_UNAVAILABLE
   error.path = path
   error.message = message
   error.cause = cause
@@ -118,7 +119,7 @@ export const Unsupported = (
   options: ConfigError.Options = { pathDelim: "." }
 ): ConfigError.ConfigError => {
   const error = Object.create(proto)
-  error._tag = OpCodes.OP_UNSUPPORTED
+  error._op = OpCodes.OP_UNSUPPORTED
   error.path = path
   error.message = message
   Object.defineProperty(error, "toString", {
@@ -135,26 +136,26 @@ export const Unsupported = (
 export const isConfigError = (u: unknown): u is ConfigError.ConfigError => hasProperty(u, ConfigErrorTypeId)
 
 /** @internal */
-export const isAnd = (self: ConfigError.ConfigError): self is ConfigError.And => self._tag === OpCodes.OP_AND
+export const isAnd = (self: ConfigError.ConfigError): self is ConfigError.And => self._op === OpCodes.OP_AND
 
 /** @internal */
-export const isOr = (self: ConfigError.ConfigError): self is ConfigError.Or => self._tag === OpCodes.OP_OR
+export const isOr = (self: ConfigError.ConfigError): self is ConfigError.Or => self._op === OpCodes.OP_OR
 
 /** @internal */
 export const isInvalidData = (self: ConfigError.ConfigError): self is ConfigError.InvalidData =>
-  self._tag === OpCodes.OP_INVALID_DATA
+  self._op === OpCodes.OP_INVALID_DATA
 
 /** @internal */
 export const isMissingData = (self: ConfigError.ConfigError): self is ConfigError.MissingData =>
-  self._tag === OpCodes.OP_MISSING_DATA
+  self._op === OpCodes.OP_MISSING_DATA
 
 /** @internal */
 export const isSourceUnavailable = (self: ConfigError.ConfigError): self is ConfigError.SourceUnavailable =>
-  self._tag === OpCodes.OP_SOURCE_UNAVAILABLE
+  self._op === OpCodes.OP_SOURCE_UNAVAILABLE
 
 /** @internal */
 export const isUnsupported = (self: ConfigError.ConfigError): self is ConfigError.Unsupported =>
-  self._tag === OpCodes.OP_UNSUPPORTED
+  self._op === OpCodes.OP_UNSUPPORTED
 
 /** @internal */
 export const prefixed: {
@@ -164,7 +165,7 @@ export const prefixed: {
   (prefix: ReadonlyArray<string>) => (self: ConfigError.ConfigError) => ConfigError.ConfigError,
   (self: ConfigError.ConfigError, prefix: ReadonlyArray<string>) => ConfigError.ConfigError
 >(2, (self, prefix) => {
-  switch (self._tag) {
+  switch (self._op) {
     case OpCodes.OP_AND: {
       return And(prefixed(self.left, prefix), prefixed(self.right, prefix))
     }
@@ -201,12 +202,12 @@ type ConfigErrorCase = AndCase | OrCase
 
 /** @internal */
 interface AndCase {
-  readonly _tag: "AndCase"
+  readonly _op: "AndCase"
 }
 
 /** @internal */
 interface OrCase {
-  readonly _tag: "OrCase"
+  readonly _op: "OrCase"
 }
 
 /** @internal */
@@ -218,17 +219,17 @@ export const reduceWithContext = dual<
   const output: Array<Either.Either<Z, ConfigErrorCase>> = []
   while (input.length > 0) {
     const error = input.pop()!
-    switch (error._tag) {
+    switch (error._op) {
       case OpCodes.OP_AND: {
         input.push(error.right)
         input.push(error.left)
-        output.push(Either.left({ _tag: "AndCase" }))
+        output.push(Either.left({ _op: "AndCase" }))
         break
       }
       case OpCodes.OP_OR: {
         input.push(error.right)
         input.push(error.left)
-        output.push(Either.left({ _tag: "OrCase" }))
+        output.push(Either.left({ _op: "OrCase" }))
         break
       }
       case OpCodes.OP_INVALID_DATA: {
@@ -252,9 +253,9 @@ export const reduceWithContext = dual<
   const accumulator: Array<Z> = []
   while (output.length > 0) {
     const either = output.pop()!
-    switch (either._tag) {
+    switch (either._op) {
       case "Left": {
-        switch (either.left._tag) {
+        switch (either.left._op) {
           case "AndCase": {
             const left = accumulator.pop()!
             const right = accumulator.pop()!

package/src/internal/configProvider/pathPatch.ts

@@ -1,10 +1,10 @@
+import * as RA from "../../Array.js"
 import type * as ConfigError from "../../ConfigError.js"
 import type * as PathPatch from "../../ConfigProviderPathPatch.js"
 import * as Either from "../../Either.js"
 import { dual, pipe } from "../../Function.js"
 import * as List from "../../List.js"
 import * as Option from "../../Option.js"
-import * as RA from "../../ReadonlyArray.js"
 import * as configError from "../configError.js"
 
 /** @internal */

package/src/internal/configProvider.ts

@@ -1,3 +1,4 @@
+import * as Arr from "../Array.js"
 import type * as Config from "../Config.js"
 import type * as ConfigError from "../ConfigError.js"
 import type * as ConfigProvider from "../ConfigProvider.js"
@@ -12,7 +13,6 @@ 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 ReadonlyArray from "../ReadonlyArray.js"
 import * as regexp from "../RegExp.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
@@ -85,12 +85,12 @@ export const makeFlat = (
 export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvider.ConfigProvider =>
   make({
     load: (config) =>
-      core.flatMap(fromFlatLoop(flat, ReadonlyArray.empty(), config, false), (chunk) =>
-        Option.match(ReadonlyArray.head(chunk), {
+      core.flatMap(fromFlatLoop(flat, Arr.empty(), config, false), (chunk) =>
+        Option.match(Arr.head(chunk), {
           onNone: () =>
             core.fail(
               configError.MissingData(
-                ReadonlyArray.empty(),
+                Arr.empty(),
                 `Expected a single value having structure: ${config}`
               )
             ),
@@ -104,7 +104,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, ReadonlyArray.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
 
   const getEnv = () =>
@@ -131,10 +131,10 @@ export const fromEnv = (
     core.sync(() => {
       const current = getEnv()
       const keys = Object.keys(current)
-      const keyPaths = Array.from(keys).map((value) => unmakePathString(value.toUpperCase()))
+      const keyPaths = keys.map((value) => unmakePathString(value.toUpperCase()))
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
+          const pathComponent = pipe(path, Arr.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -154,11 +154,11 @@ 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, ReadonlyArray.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
   const mapWithIndexSplit = splitIndexInKeys(
     map,
-    (str) => Array.from(unmakePathString(str)),
+    (str) => unmakePathString(str),
     makePathString
   )
   const load = <A>(
@@ -180,10 +180,10 @@ export const fromMap = (
     path: ReadonlyArray<string>
   ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
     core.sync(() => {
-      const keyPaths = Array.from(mapWithIndexSplit.keys()).map(unmakePathString)
+      const keyPaths = Arr.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
+          const pathComponent = pipe(path, Arr.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -203,14 +203,14 @@ const extend = <A, B>(
   left: ReadonlyArray<A>,
   right: ReadonlyArray<B>
 ): [ReadonlyArray<A>, ReadonlyArray<B>] => {
-  const leftPad = ReadonlyArray.unfold(
+  const leftPad = Arr.unfold(
     left.length,
     (index) =>
       index >= right.length ?
         Option.none() :
         Option.some([leftDef(index), index + 1])
   )
-  const rightPad = ReadonlyArray.unfold(
+  const rightPad = Arr.unfold(
     right.length,
     (index) =>
       index >= left.length ?
@@ -244,7 +244,7 @@ const fromFlatLoop = <A>(
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(ReadonlyArray.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      return core.succeed(Arr.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_DESCRIBED: {
       return core.suspend(
@@ -296,7 +296,7 @@ const fromFlatLoop = <A>(
       return core.suspend(() =>
         fromFlatLoop(
           flat,
-          concat(prefix, ReadonlyArray.of(op.name)),
+          concat(prefix, Arr.of(op.name)),
           op.config,
           split
         )
@@ -310,7 +310,7 @@ const fromFlatLoop = <A>(
             flat.load(prefix, op, split),
             core.flatMap((values) => {
               if (values.length === 0) {
-                const name = pipe(ReadonlyArray.last(prefix), Option.getOrElse(() => "<n/a>"))
+                const name = pipe(Arr.last(prefix), Option.getOrElse(() => "<n/a>"))
                 return core.fail(configError.MissingData([], `Expected ${op.description} with name ${name}`))
               }
               return core.succeed(values)
@@ -329,20 +329,20 @@ const fromFlatLoop = <A>(
             core.flatMap((indices) => {
               if (indices.length === 0) {
                 return core.suspend(() =>
-                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), ReadonlyArray.of)
+                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Arr.of)
                 ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
                   indices,
-                  (index) => fromFlatLoop(flat, ReadonlyArray.append(prefix, `[${index}]`), op.config, true)
+                  (index) => fromFlatLoop(flat, Arr.append(prefix, `[${index}]`), op.config, true)
                 ),
                 core.map((chunkChunk) => {
-                  const flattened = ReadonlyArray.flatten(chunkChunk)
+                  const flattened = Arr.flatten(chunkChunk)
                   if (flattened.length === 0) {
-                    return ReadonlyArray.of(ReadonlyArray.empty<A>())
+                    return Arr.of(Arr.empty<A>())
                   }
-                  return ReadonlyArray.of(flattened)
+                  return Arr.of(flattened)
                 })
               ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
             })
@@ -363,21 +363,18 @@ const fromFlatLoop = <A>(
                   core.forEachSequential((key) =>
                     fromFlatLoop(
                       flat,
-                      concat(prefix, ReadonlyArray.of(key)),
+                      concat(prefix, Arr.of(key)),
                       op.valueConfig,
                       split
                     )
                   ),
-                  core.map((values) => {
-                    if (values.length === 0) {
-                      return ReadonlyArray.of(HashMap.empty())
+                  core.map((matrix) => {
+                    if (matrix.length === 0) {
+                      return Arr.of(HashMap.empty())
                     }
-                    const matrix = values.map((x) => Array.from(x))
                     return pipe(
                       transpose(matrix),
-                      ReadonlyArray.map((values) =>
-                        HashMap.fromIterable(ReadonlyArray.zip(ReadonlyArray.fromIterable(keys), values))
-                      )
+                      Arr.map((values) => HashMap.fromIterable(Arr.zip(Arr.fromIterable(keys), values)))
                     )
                   })
                 )
@@ -407,17 +404,17 @@ const fromFlatLoop = <A>(
                   return core.fail(right.left)
                 }
                 if (Either.isRight(left) && Either.isRight(right)) {
-                  const path = pipe(prefix, ReadonlyArray.join("."))
+                  const path = pipe(prefix, Arr.join("."))
                   const fail = fromFlatLoopFail(prefix, path)
                   const [lefts, rights] = extend(
                     fail,
                     fail,
-                    pipe(left.right, ReadonlyArray.map(Either.right)),
-                    pipe(right.right, ReadonlyArray.map(Either.right))
+                    pipe(left.right, Arr.map(Either.right)),
+                    pipe(right.right, Arr.map(Either.right))
                   )
                   return pipe(
                     lefts,
-                    ReadonlyArray.zip(rights),
+                    Arr.zip(rights),
                     core.forEachSequential(([left, right]) =>
                       pipe(
                         core.zip(left, right),
@@ -590,8 +587,8 @@ export const within = dual<
     f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
   ) => ConfigProvider.ConfigProvider
 >(3, (self, path, f) => {
-  const unnest = ReadonlyArray.reduce(path, self, (provider, name) => unnested(provider, name))
-  const nest = ReadonlyArray.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
+  const unnest = Arr.reduce(path, self, (provider, name) => unnested(provider, name))
+  const nest = Arr.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
   return orElse(nest, () => self)
 })
 
@@ -612,7 +609,7 @@ const parsePrimitive = <A>(
       primitive.parse(text),
       core.mapBoth({
         onFailure: configError.prefixed(path),
-        onSuccess: ReadonlyArray.of
+        onSuccess: Arr.of
       })
     )
   }
@@ -631,8 +628,8 @@ const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<Read
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({
-      onFailure: () => ReadonlyArray.empty<number>(),
-      onSuccess: ReadonlyArray.sort(number.Order)
+      onFailure: () => Arr.empty<number>(),
+      onSuccess: Arr.sort(number.Order)
     }),
     core.either,
     core.map(Either.merge)
@@ -664,10 +661,10 @@ const splitIndexInKeys = (
   for (const [pathString, value] of map) {
     const keyWithIndex = pipe(
       unmakePathString(pathString),
-      ReadonlyArray.flatMap((key) =>
+      Arr.flatMap((key) =>
         Option.match(splitIndexFrom(key), {
-          onNone: () => ReadonlyArray.of(key),
-          onSome: ([key, index]) => ReadonlyArray.make(key, `[${index}]`)
+          onNone: () => Arr.of(key),
+          onSome: ([key, index]) => Arr.make(key, `[${index}]`)
         })
       )
     )
@@ -720,7 +717,7 @@ interface JsonArray extends Array<string | number | boolean | null | JsonArray |
 /** @internal */
 export const fromJson = (json: unknown): ConfigProvider.ConfigProvider => {
   const hiddenDelimiter = "\ufeff"
-  const indexedEntries = ReadonlyArray.map(
+  const indexedEntries = Arr.map(
     getIndexedEntries(json as JsonMap),
     ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
   )
@@ -762,38 +759,38 @@ const getIndexedEntries = (
     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])
+      return Arr.make([path, value] as [ReadonlyArray<KeyComponent>, string])
     }
     if (typeof value === "number" || typeof value === "boolean") {
-      return ReadonlyArray.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
+      return Arr.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
     }
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
       return loopArray(path, value)
     }
     if (typeof value === "object" && value !== null) {
       return loopObject(path, value)
     }
-    return ReadonlyArray.empty<[ReadonlyArray<KeyComponent>, string]>()
+    return Arr.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))
+    Arr.match(values, {
+      onEmpty: () => Arr.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
+      onNonEmpty: Arr.flatMap((value, index) => loopAny(Arr.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 newPath = Arr.append(path, keyName(key))
       const result = loopAny(newPath, value)
-      if (ReadonlyArray.isEmptyReadonlyArray(result)) {
-        return ReadonlyArray.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
+      if (Arr.isEmptyReadonlyArray(result)) {
+        return Arr.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
       }
       return result
     })
-  return loopObject(ReadonlyArray.empty(), config)
+  return loopObject(Arr.empty(), config)
 }