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

package/src/internal/defaultServices/console.ts

@@ -0,0 +1,100 @@
+/* eslint-disable no-console */
+import type * as Console from "../../Console.js"
+import * as Context from "../../Context.js"
+import * as core from "../core.js"
+
+/** @internal */
+export const TypeId: Console.TypeId = Symbol.for("effect/Console") as Console.TypeId
+
+/** @internal */
+export const consoleTag: Context.Tag<Console.Console, Console.Console> = Context.GenericTag<Console.Console>(
+  "effect/Console"
+)
+
+/** @internal */
+export const defaultConsole: Console.Console = {
+  [TypeId]: TypeId,
+  assert(condition, ...args) {
+    return core.sync(() => {
+      console.assert(condition, ...args)
+    })
+  },
+  clear: core.sync(() => {
+    console.clear()
+  }),
+  count(label) {
+    return core.sync(() => {
+      console.count(label)
+    })
+  },
+  countReset(label) {
+    return core.sync(() => {
+      console.countReset(label)
+    })
+  },
+  debug(...args) {
+    return core.sync(() => {
+      console.debug(...args)
+    })
+  },
+  dir(item, options) {
+    return core.sync(() => {
+      console.dir(item, options)
+    })
+  },
+  dirxml(...args) {
+    return core.sync(() => {
+      console.dirxml(...args)
+    })
+  },
+  error(...args) {
+    return core.sync(() => {
+      console.error(...args)
+    })
+  },
+  group(options) {
+    return options?.collapsed ?
+      core.sync(() => console.groupCollapsed(options?.label)) :
+      core.sync(() => console.group(options?.label))
+  },
+  groupEnd: core.sync(() => {
+    console.groupEnd()
+  }),
+  info(...args) {
+    return core.sync(() => {
+      console.info(...args)
+    })
+  },
+  log(...args) {
+    return core.sync(() => {
+      console.log(...args)
+    })
+  },
+  table(tabularData, properties) {
+    return core.sync(() => {
+      console.table(tabularData, properties)
+    })
+  },
+  time(label) {
+    return core.sync(() => console.time(label))
+  },
+  timeEnd(label) {
+    return core.sync(() => console.timeEnd(label))
+  },
+  timeLog(label, ...args) {
+    return core.sync(() => {
+      console.timeLog(label, ...args)
+    })
+  },
+  trace(...args) {
+    return core.sync(() => {
+      console.trace(...args)
+    })
+  },
+  warn(...args) {
+    return core.sync(() => {
+      console.warn(...args)
+    })
+  },
+  unsafe: console
+}

package/src/internal/defaultServices.ts

@@ -0,0 +1,163 @@
+import * as Array from "../Array.js"
+import type * as Chunk from "../Chunk.js"
+import type * as Clock from "../Clock.js"
+import type * as Config from "../Config.js"
+import type * as ConfigProvider from "../ConfigProvider.js"
+import * as Context from "../Context.js"
+import type * as DefaultServices from "../DefaultServices.js"
+import * as Duration from "../Duration.js"
+import type * as Effect from "../Effect.js"
+import { dual, pipe } from "../Function.js"
+import { globalValue } from "../GlobalValue.js"
+import type * as Random from "../Random.js"
+import type * as Tracer from "../Tracer.js"
+import * as clock from "./clock.js"
+import * as configProvider from "./configProvider.js"
+import * as core from "./core.js"
+import * as console_ from "./defaultServices/console.js"
+import * as random from "./random.js"
+import * as tracer from "./tracer.js"
+
+/** @internal */
+export const liveServices: Context.Context<DefaultServices.DefaultServices> = pipe(
+  Context.empty(),
+  Context.add(clock.clockTag, clock.make()),
+  Context.add(console_.consoleTag, console_.defaultConsole),
+  Context.add(random.randomTag, random.make(Math.random())),
+  Context.add(configProvider.configProviderTag, configProvider.fromEnv()),
+  Context.add(tracer.tracerTag, tracer.nativeTracer)
+)
+
+/**
+ * The `FiberRef` holding the default `Effect` services.
+ *
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+export const currentServices = globalValue(
+  Symbol.for("effect/DefaultServices/currentServices"),
+  () => core.fiberRefUnsafeMakeContext(liveServices)
+)
+
+// circular with Clock
+
+/** @internal */
+export const sleep = (duration: Duration.DurationInput): Effect.Effect<void> => {
+  const decodedDuration = Duration.decode(duration)
+  return clockWith((clock) => clock.sleep(decodedDuration))
+}
+
+/** @internal */
+export const defaultServicesWith = <A, E, R>(
+  f: (services: Context.Context<DefaultServices.DefaultServices>) => Effect.Effect<A, E, R>
+) => core.withFiberRuntime<A, E, R>((fiber) => f(fiber.currentDefaultServices))
+
+/** @internal */
+export const clockWith = <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  defaultServicesWith((services) => f(services.unsafeMap.get(clock.clockTag.key)))
+
+/** @internal */
+export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clock.currentTimeMillis)
+
+/** @internal */
+export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => clock.currentTimeNanos)
+
+/** @internal */
+export const withClock = dual<
+  <C extends Clock.Clock>(clock: C) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <C extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, clock: C) => Effect.Effect<A, E, R>
+>(2, (effect, c) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(clock.clockTag, c)
+  )(effect))
+
+// circular with ConfigProvider
+
+/** @internal */
+export const withConfigProvider = dual<
+  (provider: ConfigProvider.ConfigProvider) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, provider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+>(2, (self, provider) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(configProvider.configProviderTag, provider)
+  )(self))
+
+/** @internal */
+export const configProviderWith = <A, E, R>(
+  f: (provider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R> =>
+  defaultServicesWith((services) => f(services.unsafeMap.get(configProvider.configProviderTag.key)))
+
+/** @internal */
+export const config = <A>(config: Config.Config<A>) => configProviderWith((_) => _.load(config))
+
+/** @internal */
+export const configOrDie = <A>(config: Config.Config<A>) => core.orDie(configProviderWith((_) => _.load(config)))
+
+// circular with Random
+
+/** @internal */
+export const randomWith = <A, E, R>(f: (random: Random.Random) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  defaultServicesWith((services) => f(services.unsafeMap.get(random.randomTag.key)))
+
+/** @internal */
+export const withRandom = dual<
+  <X extends Random.Random>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <X extends Random.Random, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(random.randomTag, value)
+  )(effect))
+
+/** @internal */
+export const next: Effect.Effect<number> = randomWith((random) => random.next)
+
+/** @internal */
+export const nextInt: Effect.Effect<number> = randomWith((random) => random.nextInt)
+
+/** @internal */
+export const nextBoolean: Effect.Effect<boolean> = randomWith((random) => random.nextBoolean)
+
+/** @internal */
+export const nextRange = (min: number, max: number): Effect.Effect<number> =>
+  randomWith((random) => random.nextRange(min, max))
+
+/** @internal */
+export const nextIntBetween = (min: number, max: number): Effect.Effect<number> =>
+  randomWith((random) => random.nextIntBetween(min, max))
+
+/** @internal */
+export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> =>
+  randomWith((random) => random.shuffle(elements))
+
+/** @internal */
+export const choice = <Self extends Iterable<unknown>>(
+  elements: Self
+) => {
+  const array = Array.fromIterable(elements)
+  return core.map(
+    array.length === 0
+      ? core.fail(new core.NoSuchElementException("Cannot select a random element from an empty array"))
+      : randomWith((random) => random.nextIntBetween(0, array.length)),
+    (i) => array[i]
+  ) as any
+}
+
+// circular with Tracer
+
+/** @internal */
+export const tracerWith = <A, E, R>(f: (tracer: Tracer.Tracer) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  defaultServicesWith((services) => f(services.unsafeMap.get(tracer.tracerTag.key)))
+
+/** @internal */
+export const withTracer = dual<
+  (value: Tracer.Tracer) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, value: Tracer.Tracer) => Effect.Effect<A, E, R>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(tracer.tracerTag, value)
+  )(effect))

package/src/internal/deferred.ts

@@ -0,0 +1,46 @@
+import type * as Deferred from "../Deferred.js"
+import type * as Effect from "../Effect.js"
+import * as OpCodes from "./opCodes/deferred.js"
+
+/** @internal */
+const DeferredSymbolKey = "effect/Deferred"
+
+/** @internal */
+export const DeferredTypeId: Deferred.DeferredTypeId = Symbol.for(
+  DeferredSymbolKey
+) as Deferred.DeferredTypeId
+
+/** @internal */
+export const deferredVariance = {
+  /* c8 ignore next */
+  _E: (_: any) => _,
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+/** @internal */
+export type State</* in out */ A, /* in out */ E> = Pending<A, E> | Done<A, E>
+
+/** @internal */
+export interface Pending<in A, in E> {
+  readonly _tag: "Pending"
+  readonly joiners: Array<(effect: Effect.Effect<A, E>) => void>
+}
+
+/** @internal */
+export interface Done<out A, out E> {
+  readonly _tag: "Done"
+  readonly effect: Effect.Effect<A, E>
+}
+
+/** @internal */
+export const pending = <A, E>(
+  joiners: Array<(effect: Effect.Effect<A, E>) => void>
+): State<A, E> => {
+  return { _tag: OpCodes.OP_STATE_PENDING, joiners }
+}
+
+/** @internal */
+export const done = <A, E>(effect: Effect.Effect<A, E>): State<A, E> => {
+  return { _tag: OpCodes.OP_STATE_DONE, effect }
+}

package/src/internal/differ/chunkPatch.ts

@@ -0,0 +1,211 @@
+import * as Chunk from "../../Chunk.js"
+import type * as Differ from "../../Differ.js"
+import * as Equal from "../../Equal.js"
+import * as Dual from "../../Function.js"
+import { pipe } from "../../Function.js"
+import * as Data from "../data.js"
+
+/** @internal */
+export const ChunkPatchTypeId: Differ.Differ.Chunk.TypeId = Symbol.for(
+  "effect/DifferChunkPatch"
+) as Differ.Differ.Chunk.TypeId
+
+function variance<A, B>(a: A): B {
+  return a as unknown as B
+}
+
+const PatchProto = {
+  ...Data.Structural.prototype,
+  [ChunkPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+}
+
+interface Empty<Value, Patch> extends Differ.Differ.Chunk.Patch<Value, Patch> {
+  readonly _tag: "Empty"
+}
+
+const EmptyProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Empty"
+})
+
+const _empty = Object.create(EmptyProto)
+
+/**
+ * @internal
+ */
+export const empty = <Value, Patch>(): Differ.Differ.Chunk.Patch<Value, Patch> => _empty
+
+interface AndThen<Value, Patch> extends Differ.Differ.Chunk.Patch<Value, Patch> {
+  readonly _tag: "AndThen"
+  readonly first: Differ.Differ.Chunk.Patch<Value, Patch>
+  readonly second: Differ.Differ.Chunk.Patch<Value, Patch>
+}
+
+const AndThenProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AndThen"
+})
+
+const makeAndThen = <Value, Patch>(
+  first: Differ.Differ.Chunk.Patch<Value, Patch>,
+  second: Differ.Differ.Chunk.Patch<Value, Patch>
+): Differ.Differ.Chunk.Patch<Value, Patch> => {
+  const o = Object.create(AndThenProto)
+  o.first = first
+  o.second = second
+  return o
+}
+
+interface Append<Value, Patch> extends Differ.Differ.Chunk.Patch<Value, Patch> {
+  readonly _tag: "Append"
+  readonly values: Chunk.Chunk<Value>
+}
+
+const AppendProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Append"
+})
+
+const makeAppend = <Value, Patch>(values: Chunk.Chunk<Value>): Differ.Differ.Chunk.Patch<Value, Patch> => {
+  const o = Object.create(AppendProto)
+  o.values = values
+  return o
+}
+
+interface Slice<Value, Patch> extends Differ.Differ.Chunk.Patch<Value, Patch> {
+  readonly _tag: "Slice"
+  readonly from: number
+  readonly until: number
+}
+
+const SliceProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Slice"
+})
+
+const makeSlice = <Value, Patch>(from: number, until: number): Differ.Differ.Chunk.Patch<Value, Patch> => {
+  const o = Object.create(SliceProto)
+  o.from = from
+  o.until = until
+  return o
+}
+
+interface Update<Value, Patch> extends Differ.Differ.Chunk.Patch<Value, Patch> {
+  readonly _tag: "Update"
+  readonly index: number
+  readonly patch: Patch
+}
+
+const UpdateProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Update"
+})
+
+const makeUpdate = <Value, Patch>(index: number, patch: Patch): Differ.Differ.Chunk.Patch<Value, Patch> => {
+  const o = Object.create(UpdateProto)
+  o.index = index
+  o.patch = patch
+  return o
+}
+
+type Instruction =
+  | Empty<any, any>
+  | AndThen<any, any>
+  | Append<any, any>
+  | Slice<any, any>
+  | Update<any, any>
+
+/** @internal */
+export const diff = <Value, Patch>(
+  options: {
+    readonly oldValue: Chunk.Chunk<Value>
+    readonly newValue: Chunk.Chunk<Value>
+    readonly differ: Differ.Differ<Value, Patch>
+  }
+): Differ.Differ.Chunk.Patch<Value, Patch> => {
+  let i = 0
+  let patch = empty<Value, Patch>()
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = Chunk.unsafeGet(i)(options.oldValue)
+    const newElement = Chunk.unsafeGet(i)(options.newValue)
+    const valuePatch = options.differ.diff(oldElement, newElement)
+    if (!Equal.equals(valuePatch, options.differ.empty)) {
+      patch = pipe(patch, combine(makeUpdate(i, valuePatch)))
+    }
+    i = i + 1
+  }
+  if (i < options.oldValue.length) {
+    patch = pipe(patch, combine(makeSlice(0, i)))
+  }
+  if (i < options.newValue.length) {
+    patch = pipe(patch, combine(makeAppend(Chunk.drop(i)(options.newValue))))
+  }
+  return patch
+}
+
+/** @internal */
+export const combine = Dual.dual<
+  <Value, Patch>(
+    that: Differ.Differ.Chunk.Patch<Value, Patch>
+  ) => (
+    self: Differ.Differ.Chunk.Patch<Value, Patch>
+  ) => Differ.Differ.Chunk.Patch<Value, Patch>,
+  <Value, Patch>(
+    self: Differ.Differ.Chunk.Patch<Value, Patch>,
+    that: Differ.Differ.Chunk.Patch<Value, Patch>
+  ) => Differ.Differ.Chunk.Patch<Value, Patch>
+>(2, (self, that) => makeAndThen(self, that))
+
+/** @internal */
+export const patch = Dual.dual<
+  <Value, Patch>(
+    oldValue: Chunk.Chunk<Value>,
+    differ: Differ.Differ<Value, Patch>
+  ) => (self: Differ.Differ.Chunk.Patch<Value, Patch>) => Chunk.Chunk<Value>,
+  <Value, Patch>(
+    self: Differ.Differ.Chunk.Patch<Value, Patch>,
+    oldValue: Chunk.Chunk<Value>,
+    differ: Differ.Differ<Value, Patch>
+  ) => Chunk.Chunk<Value>
+>(3, <Value, Patch>(
+  self: Differ.Differ.Chunk.Patch<Value, Patch>,
+  oldValue: Chunk.Chunk<Value>,
+  differ: Differ.Differ<Value, Patch>
+) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
+  let chunk = oldValue
+  let patches: Chunk.Chunk<Differ.Differ.Chunk.Patch<Value, Patch>> = Chunk.of(self)
+  while (Chunk.isNonEmpty(patches)) {
+    const head: Instruction = Chunk.headNonEmpty(patches) as Instruction
+    const tail = Chunk.tailNonEmpty(patches)
+    switch (head._tag) {
+      case "Empty": {
+        patches = tail
+        break
+      }
+      case "AndThen": {
+        patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(tail))
+        break
+      }
+      case "Append": {
+        chunk = Chunk.appendAll(head.values)(chunk)
+        patches = tail
+        break
+      }
+      case "Slice": {
+        const array = Chunk.toReadonlyArray(chunk)
+        chunk = Chunk.unsafeFromArray(array.slice(head.from, head.until))
+        patches = tail
+        break
+      }
+      case "Update": {
+        const array = Chunk.toReadonlyArray(chunk) as Array<Value>
+        array[head.index] = differ.patch(head.patch, array[head.index]!)
+        chunk = Chunk.unsafeFromArray(array)
+        patches = tail
+        break
+      }
+    }
+  }
+  return chunk
+})