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

package/src/internal/array.ts

@@ -0,0 +1,8 @@
+/**
+ * @since 2.0.0
+ */
+
+import type { NonEmptyArray } from "../Array.js"
+
+/** @internal */
+export const isNonEmptyArray = <A>(self: ReadonlyArray<A>): self is NonEmptyArray<A> => self.length > 0

package/src/internal/blockedRequests.ts

@@ -0,0 +1,520 @@
+import * as Chunk from "../Chunk.js"
+import type * as Deferred from "../Deferred.js"
+import * as Either from "../Either.js"
+import * as Equal from "../Equal.js"
+import type { FiberId } from "../FiberId.js"
+import * as HashMap from "../HashMap.js"
+import * as List from "../List.js"
+import * as Option from "../Option.js"
+import { hasProperty } from "../Predicate.js"
+import type * as Request from "../Request.js"
+import type * as RequestBlock from "../RequestBlock.js"
+import type * as RequestResolver from "../RequestResolver.js"
+
+/** @internal */
+export const empty: RequestBlock.RequestBlock = {
+  _tag: "Empty"
+}
+
+/**
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in parallel.
+ *
+ * @internal
+ */
+export const par = (
+  self: RequestBlock.RequestBlock,
+  that: RequestBlock.RequestBlock
+): RequestBlock.RequestBlock => ({
+  _tag: "Par",
+  left: self,
+  right: that
+})
+
+/**
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in sequence.
+ *
+ * @internal
+ */
+export const seq = (
+  self: RequestBlock.RequestBlock,
+  that: RequestBlock.RequestBlock
+): RequestBlock.RequestBlock => ({
+  _tag: "Seq",
+  left: self,
+  right: that
+})
+
+/**
+ * Constructs a collection of blocked requests from the specified blocked
+ * request and data source.
+ *
+ * @internal
+ */
+export const single = <A>(
+  dataSource: RequestResolver.RequestResolver<A>,
+  blockedRequest: Request.Entry<A>
+): RequestBlock.RequestBlock => ({
+  _tag: "Single",
+  dataSource: dataSource as any,
+  blockedRequest
+})
+
+/** @internal */
+export const MapRequestResolversReducer = <A>(
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+): RequestBlock.RequestBlock.Reducer<RequestBlock.RequestBlock> => ({
+  emptyCase: () => empty,
+  parCase: (left, right) => par(left, right),
+  seqCase: (left, right) => seq(left, right),
+  singleCase: (dataSource, blockedRequest) => single(f(dataSource), blockedRequest as any)
+})
+
+type BlockedRequestsCase = ParCase | SeqCase
+
+interface ParCase {
+  readonly _tag: "ParCase"
+}
+
+interface SeqCase {
+  readonly _tag: "SeqCase"
+}
+
+/**
+ * Transforms all data sources with the specified data source aspect, which
+ * can change the environment type of data sources but must preserve the
+ * request type of each data source.
+ *
+ * @internal
+ */
+export const mapRequestResolvers = <A>(
+  self: RequestBlock.RequestBlock,
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+): RequestBlock.RequestBlock => reduce(self, MapRequestResolversReducer(f))
+
+/**
+ * Folds over the cases of this collection of blocked requests with the
+ * specified functions.
+ *
+ * @internal
+ */
+export const reduce = <Z>(
+  self: RequestBlock.RequestBlock,
+  reducer: RequestBlock.RequestBlock.Reducer<Z>
+): Z => {
+  let input: List.List<RequestBlock.RequestBlock> = List.of(self)
+  let output = List.empty<Either.Either<Z, BlockedRequestsCase>>()
+  while (List.isCons(input)) {
+    const current: RequestBlock.RequestBlock = input.head
+    switch (current._tag) {
+      case "Empty": {
+        output = List.cons(Either.right(reducer.emptyCase()), output)
+        input = input.tail
+        break
+      }
+      case "Par": {
+        output = List.cons(Either.left({ _tag: "ParCase" }), output)
+        input = List.cons(current.left, List.cons(current.right, input.tail))
+        break
+      }
+      case "Seq": {
+        output = List.cons(Either.left({ _tag: "SeqCase" }), output)
+        input = List.cons(current.left, List.cons(current.right, input.tail))
+        break
+      }
+      case "Single": {
+        const result = reducer.singleCase(current.dataSource, current.blockedRequest)
+        output = List.cons(Either.right(result), output)
+        input = input.tail
+        break
+      }
+    }
+  }
+  const result = List.reduce(output, List.empty<Z>(), (acc, current) => {
+    switch (current._tag) {
+      case "Left": {
+        const left = List.unsafeHead(acc)
+        const right = List.unsafeHead(List.unsafeTail(acc))
+        const tail = List.unsafeTail(List.unsafeTail(acc))
+        switch (current.left._tag) {
+          case "ParCase": {
+            return List.cons(reducer.parCase(left, right), tail)
+          }
+          case "SeqCase": {
+            return List.cons(reducer.seqCase(left, right), tail)
+          }
+        }
+      }
+      case "Right": {
+        return List.cons(current.right, acc)
+      }
+    }
+  })
+  if (List.isNil(result)) {
+    throw new Error(
+      "BUG: BlockedRequests.reduce - please report an issue at https://github.com/Effect-TS/effect/issues"
+    )
+  }
+  return result.head
+}
+
+/**
+ * Flattens a collection of blocked requests into a collection of pipelined
+ * and batched requests that can be submitted for execution.
+ *
+ * @internal
+ */
+export const flatten = (
+  self: RequestBlock.RequestBlock
+): List.List<SequentialCollection> => {
+  let current = List.of(self)
+  let updated = List.empty<SequentialCollection>()
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = List.reduce(
+      current,
+      [parallelCollectionEmpty(), List.empty<RequestBlock.RequestBlock>()] as const,
+      ([parallel, sequential], blockedRequest) => {
+        const [par, seq] = step(blockedRequest)
+        return [
+          parallelCollectionCombine(parallel, par),
+          List.appendAll(sequential, seq)
+        ]
+      }
+    )
+    updated = merge(updated, parallel)
+    if (List.isNil(sequential)) {
+      return List.reverse(updated)
+    }
+    current = sequential
+  }
+  throw new Error(
+    "BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/effect/issues"
+  )
+}
+
+/**
+ * Takes one step in evaluating a collection of blocked requests, returning a
+ * collection of blocked requests that can be performed in parallel and a list
+ * of blocked requests that must be performed sequentially after those
+ * requests.
+ */
+const step = (
+  requests: RequestBlock.RequestBlock
+): [ParallelCollection, List.List<RequestBlock.RequestBlock>] => {
+  let current: RequestBlock.RequestBlock = requests
+  let parallel = parallelCollectionEmpty()
+  let stack = List.empty<RequestBlock.RequestBlock>()
+  let sequential = List.empty<RequestBlock.RequestBlock>()
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    switch (current._tag) {
+      case "Empty": {
+        if (List.isNil(stack)) {
+          return [parallel, sequential]
+        }
+        current = stack.head
+        stack = stack.tail
+        break
+      }
+      case "Par": {
+        stack = List.cons(current.right, stack)
+        current = current.left
+        break
+      }
+      case "Seq": {
+        const left = current.left
+        const right = current.right
+        switch (left._tag) {
+          case "Empty": {
+            current = right
+            break
+          }
+          case "Par": {
+            const l = left.left
+            const r = left.right
+            current = par(seq(l, right), seq(r, right))
+            break
+          }
+          case "Seq": {
+            const l = left.left
+            const r = left.right
+            current = seq(l, seq(r, right))
+            break
+          }
+          case "Single": {
+            current = left
+            sequential = List.cons(right, sequential)
+            break
+          }
+        }
+        break
+      }
+      case "Single": {
+        parallel = parallelCollectionAdd(
+          parallel,
+          current
+        )
+        if (List.isNil(stack)) {
+          return [parallel, sequential]
+        }
+        current = stack.head
+        stack = stack.tail
+        break
+      }
+    }
+  }
+  throw new Error(
+    "BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/effect/issues"
+  )
+}
+
+/**
+ * Merges a collection of requests that must be executed sequentially with a
+ * collection of requests that can be executed in parallel. If the collections
+ * are both from the same single data source then the requests can be
+ * pipelined while preserving ordering guarantees.
+ */
+const merge = (
+  sequential: List.List<SequentialCollection>,
+  parallel: ParallelCollection
+): List.List<SequentialCollection> => {
+  if (List.isNil(sequential)) {
+    return List.of(parallelCollectionToSequentialCollection(parallel))
+  }
+  if (parallelCollectionIsEmpty(parallel)) {
+    return sequential
+  }
+  const seqHeadKeys = sequentialCollectionKeys(sequential.head)
+  const parKeys = parallelCollectionKeys(parallel)
+  if (
+    seqHeadKeys.length === 1 &&
+    parKeys.length === 1 &&
+    Equal.equals(seqHeadKeys[0], parKeys[0])
+  ) {
+    return List.cons(
+      sequentialCollectionCombine(
+        sequential.head,
+        parallelCollectionToSequentialCollection(parallel)
+      ),
+      sequential.tail
+    )
+  }
+  return List.cons(parallelCollectionToSequentialCollection(parallel), sequential)
+}
+
+//
+// circular
+//
+
+/** @internal */
+export const EntryTypeId: Request.EntryTypeId = Symbol.for(
+  "effect/RequestBlock/Entry"
+) as Request.EntryTypeId
+
+/** @internal */
+class EntryImpl<A extends Request.Request<any, any>> implements Request.Entry<A> {
+  readonly [EntryTypeId] = blockedRequestVariance
+  constructor(
+    readonly request: A,
+    readonly result: Deferred.Deferred<Request.Request.Success<A>, Request.Request.Error<A>>,
+    readonly listeners: Request.Listeners,
+    readonly ownerId: FiberId,
+    readonly state: {
+      completed: boolean
+    }
+  ) {}
+}
+
+const blockedRequestVariance = {
+  /* c8 ignore next */
+  _R: (_: never) => _
+}
+
+/** @internal */
+export const isEntry = (u: unknown): u is Request.Entry<unknown> => hasProperty(u, EntryTypeId)
+
+/** @internal */
+export const makeEntry = <A extends Request.Request<any, any>>(
+  options: {
+    readonly request: A
+    readonly result: Deferred.Deferred<Request.Request.Success<A>, Request.Request.Error<A>>
+    readonly listeners: Request.Listeners
+    readonly ownerId: FiberId
+    readonly state: { completed: boolean }
+  }
+): Request.Entry<A> => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state)
+
+/** @internal */
+export const RequestBlockParallelTypeId = Symbol.for(
+  "effect/RequestBlock/RequestBlockParallel"
+)
+
+const parallelVariance = {
+  /* c8 ignore next */
+  _R: (_: never) => _
+}
+
+class ParallelImpl implements ParallelCollection {
+  readonly [RequestBlockParallelTypeId] = parallelVariance
+  constructor(
+    readonly map: HashMap.HashMap<
+      RequestResolver.RequestResolver<unknown, unknown>,
+      Chunk.Chunk<Request.Entry<unknown>>
+    >
+  ) {}
+}
+
+/** @internal */
+export const parallelCollectionEmpty = (): ParallelCollection => new ParallelImpl(HashMap.empty())
+
+/** @internal */
+export const parallelCollectionMake = <A>(
+  dataSource: RequestResolver.RequestResolver<A>,
+  blockedRequest: Request.Entry<A>
+): ParallelCollection => new ParallelImpl(HashMap.make([dataSource, Chunk.of(blockedRequest)]) as any)
+
+/** @internal */
+export const parallelCollectionAdd = (
+  self: ParallelCollection,
+  blockedRequest: RequestBlock.Single
+): ParallelCollection =>
+  new ParallelImpl(HashMap.modifyAt(
+    self.map,
+    blockedRequest.dataSource,
+    (_) =>
+      Option.orElseSome(
+        Option.map(_, Chunk.append(blockedRequest.blockedRequest)),
+        () => Chunk.of(blockedRequest.blockedRequest)
+      )
+  ))
+
+/** @internal */
+export const parallelCollectionCombine = (
+  self: ParallelCollection,
+  that: ParallelCollection
+): ParallelCollection =>
+  new ParallelImpl(HashMap.reduce(self.map, that.map, (map, value, key) =>
+    HashMap.set(
+      map,
+      key,
+      Option.match(HashMap.get(map, key), {
+        onNone: () => value,
+        onSome: (other) => Chunk.appendAll(value, other)
+      })
+    )))
+
+/** @internal */
+export const parallelCollectionIsEmpty = (self: ParallelCollection): boolean => HashMap.isEmpty(self.map)
+
+/** @internal */
+export const parallelCollectionKeys = (
+  self: ParallelCollection
+): Array<RequestResolver.RequestResolver<unknown>> => Array.from(HashMap.keys(self.map)) as any
+
+/** @internal */
+export const parallelCollectionToSequentialCollection = (
+  self: ParallelCollection
+): SequentialCollection => sequentialCollectionMake(HashMap.map(self.map, (x) => Chunk.of(x)) as any)
+
+// TODO
+// /** @internal */
+// export const parallelCollectionToChunk = <R>(
+//   self: ParallelCollection<R>
+// ): Array<[RequestResolver.RequestResolver<unknown, R>, Array<Request.Entry<unknown>>]> => Array.from(self.map) as any
+
+/** @internal */
+export const SequentialCollectionTypeId = Symbol.for(
+  "effect/RequestBlock/RequestBlockSequential"
+)
+
+const sequentialVariance = {
+  /* c8 ignore next */
+  _R: (_: never) => _
+}
+
+class SequentialImpl implements SequentialCollection {
+  readonly [SequentialCollectionTypeId] = sequentialVariance
+  constructor(
+    readonly map: HashMap.HashMap<
+      RequestResolver.RequestResolver<unknown, unknown>,
+      Chunk.Chunk<Chunk.Chunk<Request.Entry<unknown>>>
+    >
+  ) {}
+}
+
+/** @internal */
+export const sequentialCollectionMake = <A, R>(
+  map: HashMap.HashMap<
+    RequestResolver.RequestResolver<A, R>,
+    Chunk.Chunk<Chunk.Chunk<Request.Entry<A>>>
+  >
+): SequentialCollection => new SequentialImpl(map as any)
+
+/** @internal */
+export const sequentialCollectionCombine = (
+  self: SequentialCollection,
+  that: SequentialCollection
+): SequentialCollection =>
+  new SequentialImpl(HashMap.reduce(that.map, self.map, (map, value, key) =>
+    HashMap.set(
+      map,
+      key,
+      Option.match(HashMap.get(map, key), {
+        onNone: () => Chunk.empty(),
+        onSome: (a) => Chunk.appendAll(a, value)
+      })
+    )))
+
+/** @internal */
+export const sequentialCollectionIsEmpty = (self: SequentialCollection): boolean => HashMap.isEmpty(self.map)
+
+/** @internal */
+export const sequentialCollectionKeys = (
+  self: SequentialCollection
+): Array<RequestResolver.RequestResolver<unknown>> => Array.from(HashMap.keys(self.map)) as any
+
+/** @internal */
+export const sequentialCollectionToChunk = (
+  self: SequentialCollection
+): Array<[RequestResolver.RequestResolver<unknown>, Chunk.Chunk<Chunk.Chunk<Request.Entry<unknown>>>]> =>
+  Array.from(self.map) as any
+
+/** @internal */
+export type RequestBlockParallelTypeId = typeof RequestBlockParallelTypeId
+
+/** @internal */
+export interface ParallelCollection extends ParallelCollection.Variance {
+  readonly map: HashMap.HashMap<
+    RequestResolver.RequestResolver<unknown, unknown>,
+    Chunk.Chunk<Request.Entry<unknown>>
+  >
+}
+
+/** @internal */
+export declare namespace ParallelCollection {
+  /** @internal */
+  export interface Variance {
+    readonly [RequestBlockParallelTypeId]: {}
+  }
+}
+
+/** @internal */
+export type SequentialCollectionTypeId = typeof SequentialCollectionTypeId
+
+/** @internal */
+export interface SequentialCollection extends SequentialCollection.Variance {
+  readonly map: HashMap.HashMap<
+    RequestResolver.RequestResolver<unknown, unknown>,
+    Chunk.Chunk<Chunk.Chunk<Request.Entry<unknown>>>
+  >
+}
+
+/** @internal */
+export declare namespace SequentialCollection {
+  /** @internal */
+  export interface Variance {
+    readonly [SequentialCollectionTypeId]: {}
+  }
+}