@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/encoding/hex.ts

@@ -0,0 +1,315 @@
+import * as Either from "../../Either.js"
+import type * as Encoding from "../../Encoding.js"
+import { DecodeException } from "./common.js"
+
+/** @internal */
+export const encode = (bytes: Uint8Array) => {
+  let result = ""
+  for (let i = 0; i < bytes.length; ++i) {
+    result += bytesToHex[bytes[i]]
+  }
+
+  return result
+}
+
+/** @internal */
+export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
+  const bytes = new TextEncoder().encode(str)
+  if (bytes.length % 2 !== 0) {
+    return Either.left(DecodeException(str, `Length must be a multiple of 2, but is ${bytes.length}`))
+  }
+
+  try {
+    const length = bytes.length / 2
+    const result = new Uint8Array(length)
+    for (let i = 0; i < length; i++) {
+      const a = fromHexChar(bytes[i * 2])
+      const b = fromHexChar(bytes[i * 2 + 1])
+      result[i] = (a << 4) | b
+    }
+
+    return Either.right(result)
+  } catch (e) {
+    return Either.left(DecodeException(str, e instanceof Error ? e.message : "Invalid input"))
+  }
+}
+
+/** @internal */
+const bytesToHex = [
+  "00",
+  "01",
+  "02",
+  "03",
+  "04",
+  "05",
+  "06",
+  "07",
+  "08",
+  "09",
+  "0a",
+  "0b",
+  "0c",
+  "0d",
+  "0e",
+  "0f",
+  "10",
+  "11",
+  "12",
+  "13",
+  "14",
+  "15",
+  "16",
+  "17",
+  "18",
+  "19",
+  "1a",
+  "1b",
+  "1c",
+  "1d",
+  "1e",
+  "1f",
+  "20",
+  "21",
+  "22",
+  "23",
+  "24",
+  "25",
+  "26",
+  "27",
+  "28",
+  "29",
+  "2a",
+  "2b",
+  "2c",
+  "2d",
+  "2e",
+  "2f",
+  "30",
+  "31",
+  "32",
+  "33",
+  "34",
+  "35",
+  "36",
+  "37",
+  "38",
+  "39",
+  "3a",
+  "3b",
+  "3c",
+  "3d",
+  "3e",
+  "3f",
+  "40",
+  "41",
+  "42",
+  "43",
+  "44",
+  "45",
+  "46",
+  "47",
+  "48",
+  "49",
+  "4a",
+  "4b",
+  "4c",
+  "4d",
+  "4e",
+  "4f",
+  "50",
+  "51",
+  "52",
+  "53",
+  "54",
+  "55",
+  "56",
+  "57",
+  "58",
+  "59",
+  "5a",
+  "5b",
+  "5c",
+  "5d",
+  "5e",
+  "5f",
+  "60",
+  "61",
+  "62",
+  "63",
+  "64",
+  "65",
+  "66",
+  "67",
+  "68",
+  "69",
+  "6a",
+  "6b",
+  "6c",
+  "6d",
+  "6e",
+  "6f",
+  "70",
+  "71",
+  "72",
+  "73",
+  "74",
+  "75",
+  "76",
+  "77",
+  "78",
+  "79",
+  "7a",
+  "7b",
+  "7c",
+  "7d",
+  "7e",
+  "7f",
+  "80",
+  "81",
+  "82",
+  "83",
+  "84",
+  "85",
+  "86",
+  "87",
+  "88",
+  "89",
+  "8a",
+  "8b",
+  "8c",
+  "8d",
+  "8e",
+  "8f",
+  "90",
+  "91",
+  "92",
+  "93",
+  "94",
+  "95",
+  "96",
+  "97",
+  "98",
+  "99",
+  "9a",
+  "9b",
+  "9c",
+  "9d",
+  "9e",
+  "9f",
+  "a0",
+  "a1",
+  "a2",
+  "a3",
+  "a4",
+  "a5",
+  "a6",
+  "a7",
+  "a8",
+  "a9",
+  "aa",
+  "ab",
+  "ac",
+  "ad",
+  "ae",
+  "af",
+  "b0",
+  "b1",
+  "b2",
+  "b3",
+  "b4",
+  "b5",
+  "b6",
+  "b7",
+  "b8",
+  "b9",
+  "ba",
+  "bb",
+  "bc",
+  "bd",
+  "be",
+  "bf",
+  "c0",
+  "c1",
+  "c2",
+  "c3",
+  "c4",
+  "c5",
+  "c6",
+  "c7",
+  "c8",
+  "c9",
+  "ca",
+  "cb",
+  "cc",
+  "cd",
+  "ce",
+  "cf",
+  "d0",
+  "d1",
+  "d2",
+  "d3",
+  "d4",
+  "d5",
+  "d6",
+  "d7",
+  "d8",
+  "d9",
+  "da",
+  "db",
+  "dc",
+  "dd",
+  "de",
+  "df",
+  "e0",
+  "e1",
+  "e2",
+  "e3",
+  "e4",
+  "e5",
+  "e6",
+  "e7",
+  "e8",
+  "e9",
+  "ea",
+  "eb",
+  "ec",
+  "ed",
+  "ee",
+  "ef",
+  "f0",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "fa",
+  "fb",
+  "fc",
+  "fd",
+  "fe",
+  "ff"
+]
+
+/** @internal */
+const fromHexChar = (byte: number) => {
+  // '0' <= byte && byte <= '9'
+  if (48 <= byte && byte <= 57) {
+    return byte - 48
+  }
+
+  // 'a' <= byte && byte <= 'f'
+  if (97 <= byte && byte <= 102) {
+    return byte - 97 + 10
+  }
+
+  // 'A' <= byte && byte <= 'F'
+  if (65 <= byte && byte <= 70) {
+    return byte - 65 + 10
+  }
+
+  throw new TypeError("Invalid input")
+}

package/src/internal/errors.ts

@@ -0,0 +1,7 @@
+/**
+ * @since 2.0.0
+ */
+
+/** @internal */
+export const getBugErrorMessage = (message: string) =>
+  `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`

package/src/internal/executionPlan.ts

@@ -0,0 +1,114 @@
+import type { Effect } from "../Effect.js"
+import * as Either from "../Either.js"
+import type * as Api from "../ExecutionPlan.js"
+import { dual } from "../Function.js"
+import * as Predicate from "../Predicate.js"
+import * as core from "./core.js"
+import * as layer from "./layer.js"
+import * as InternalSchedule from "./schedule.js"
+
+/** @internal */
+export const TypeId: Api.TypeId = Symbol.for("effect/ExecutionPlan") as Api.TypeId
+
+/** @internal */
+export const isExecutionPlan = (u: unknown): u is Api.ExecutionPlan<any> => Predicate.hasProperty(u, TypeId)
+
+/** @internal */
+export const withExecutionPlan: {
+  <Input, Provides, PlanE, PlanR>(
+    plan: Api.ExecutionPlan<{
+      provides: Provides
+      input: Input
+      error: PlanE
+      requirements: PlanR
+    }>
+  ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<
+    A,
+    E | PlanE,
+    Exclude<R, Provides> | PlanR
+  >
+  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+    effect: Effect<A, E, R>,
+    plan: Api.ExecutionPlan<{
+      provides: Provides
+      input: Input
+      error: PlanE
+      requirements: PlanR
+    }>
+  ): Effect<
+    A,
+    E | PlanE,
+    Exclude<R, Provides> | PlanR
+  >
+} = dual(2, <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+  effect: Effect<A, E, R>,
+  plan: Api.ExecutionPlan<{
+    provides: Provides
+    input: Input
+    error: PlanE
+    requirements: PlanR
+  }>
+) =>
+  core.suspend(() => {
+    let i = 0
+    let result: Either.Either<A, any> | undefined
+    return core.flatMap(
+      core.whileLoop({
+        while: () => i < plan.steps.length && (result === undefined || Either.isLeft(result)),
+        body: () => {
+          const step = plan.steps[i]
+          let nextEffect: Effect<A, any, any> = layer.effect_provide(effect, step.provide as any)
+          if (result) {
+            let attempted = false
+            const wrapped = nextEffect
+            // ensure the schedule is applied at least once
+            nextEffect = core.suspend(() => {
+              if (attempted) return wrapped
+              attempted = true
+              return result!
+            })
+            nextEffect = InternalSchedule.scheduleDefectRefail(
+              InternalSchedule.retry_Effect(nextEffect, scheduleFromStep(step, false)!)
+            )
+          } else {
+            const schedule = scheduleFromStep(step, true)
+            nextEffect = schedule
+              ? InternalSchedule.scheduleDefectRefail(InternalSchedule.retry_Effect(nextEffect, schedule))
+              : nextEffect
+          }
+          return core.either(nextEffect)
+        },
+        step: (either) => {
+          result = either
+          i++
+        }
+      }),
+      () => result!
+    )
+  }))
+
+/** @internal */
+export const scheduleFromStep = <Provides, In, PlanE, PlanR>(
+  step: Api.ExecutionPlan<{
+    provides: Provides
+    input: In
+    error: PlanE
+    requirements: PlanR
+  }>["steps"][number],
+  first: boolean
+) => {
+  if (!first) {
+    return InternalSchedule.fromRetryOptions({
+      schedule: step.schedule ? step.schedule : step.attempts ? undefined : InternalSchedule.once,
+      times: step.attempts,
+      while: step.while
+    })
+  } else if (step.attempts === 1 || !(step.schedule || step.attempts)) {
+    return undefined
+  }
+  return InternalSchedule.fromRetryOptions({
+    schedule: step.schedule,
+    while: step.while,
+    times: step.attempts ? step.attempts - 1 : undefined
+  })
+}

package/src/internal/executionStrategy.ts

@@ -0,0 +1,74 @@
+import type * as ExecutionStrategy from "../ExecutionStrategy.js"
+import { dual } from "../Function.js"
+import type { LazyArg } from "../Function.js"
+
+/** @internal */
+export const OP_SEQUENTIAL = "Sequential" as const
+
+/** @internal */
+export type OP_SEQUENTIAL = typeof OP_SEQUENTIAL
+
+/** @internal */
+export const OP_PARALLEL = "Parallel" as const
+
+/** @internal */
+export type OP_PARALLEL = typeof OP_PARALLEL
+
+/** @internal */
+export const OP_PARALLEL_N = "ParallelN" as const
+
+/** @internal */
+export type OP_PARALLEL_N = typeof OP_PARALLEL_N
+
+/** @internal */
+export const sequential: ExecutionStrategy.ExecutionStrategy = { _tag: OP_SEQUENTIAL }
+
+/** @internal */
+export const parallel: ExecutionStrategy.ExecutionStrategy = { _tag: OP_PARALLEL }
+
+/** @internal */
+export const parallelN = (parallelism: number): ExecutionStrategy.ExecutionStrategy => ({
+  _tag: OP_PARALLEL_N,
+  parallelism
+})
+
+/** @internal */
+export const isSequential = (self: ExecutionStrategy.ExecutionStrategy): self is ExecutionStrategy.Sequential =>
+  self._tag === OP_SEQUENTIAL
+
+/** @internal */
+export const isParallel = (self: ExecutionStrategy.ExecutionStrategy): self is ExecutionStrategy.Parallel =>
+  self._tag === OP_PARALLEL
+
+/** @internal */
+export const isParallelN = (self: ExecutionStrategy.ExecutionStrategy): self is ExecutionStrategy.ParallelN =>
+  self._tag === OP_PARALLEL_N
+
+/** @internal */
+export const match = dual<
+  <A>(options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }) => (self: ExecutionStrategy.ExecutionStrategy) => A,
+  <A>(
+    self: ExecutionStrategy.ExecutionStrategy,
+    options: {
+      readonly onSequential: LazyArg<A>
+      readonly onParallel: LazyArg<A>
+      readonly onParallelN: (n: number) => A
+    }
+  ) => A
+>(2, (self, options) => {
+  switch (self._tag) {
+    case OP_SEQUENTIAL: {
+      return options.onSequential()
+    }
+    case OP_PARALLEL: {
+      return options.onParallel()
+    }
+    case OP_PARALLEL_N: {
+      return options.onParallelN(self.parallelism)
+    }
+  }
+})