Lorem Ipsum MCP Server

import * as Chunk from "../Chunk.js"; import * as Either from "../Either.js"; import * as Equal from "../Equal.js"; import * as HashMap from "../HashMap.js"; import * as List from "../List.js"; import * as Option from "../Option.js"; import { hasProperty } from "../Predicate.js"; /** @internal */ export const empty = { _tag: "Empty" }; /** * Combines this collection of blocked requests with the specified collection * of blocked requests, in parallel. * * @internal */ export const par = (self, that) => ({ _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, that) => ({ _tag: "Seq", left: self, right: that }); /** * Constructs a collection of blocked requests from the specified blocked * request and data source. * * @internal */ export const single = (dataSource, blockedRequest) => ({ _tag: "Single", dataSource: dataSource, blockedRequest }); /** @internal */ export const MapRequestResolversReducer = f => ({ emptyCase: () => empty, parCase: (left, right) => par(left, right), seqCase: (left, right) => seq(left, right), singleCase: (dataSource, blockedRequest) => single(f(dataSource), blockedRequest) }); /** * 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 = (self, f) => reduce(self, MapRequestResolversReducer(f)); /** * Folds over the cases of this collection of blocked requests with the * specified functions. * * @internal */ export const reduce = (self, reducer) => { let input = List.of(self); let output = List.empty(); while (List.isCons(input)) { const current = 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(), (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 => { let current = List.of(self); let updated = List.empty(); // eslint-disable-next-line no-constant-condition while (1) { const [parallel, sequential] = List.reduce(current, [parallelCollectionEmpty(), List.empty()], ([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 => { let current = requests; let parallel = parallelCollectionEmpty(); let stack = List.empty(); let sequential = List.empty(); // 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, parallel) => { 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 = /*#__PURE__*/Symbol.for("effect/RequestBlock/Entry"); /** @internal */ class EntryImpl { request; result; listeners; ownerId; state; [EntryTypeId] = blockedRequestVariance; constructor(request, result, listeners, ownerId, state) { this.request = request; this.result = result; this.listeners = listeners; this.ownerId = ownerId; this.state = state; } } const blockedRequestVariance = { /* c8 ignore next */ _R: _ => _ }; /** @internal */ export const isEntry = u => hasProperty(u, EntryTypeId); /** @internal */ export const makeEntry = options => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state); /** @internal */ export const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel"); const parallelVariance = { /* c8 ignore next */ _R: _ => _ }; class ParallelImpl { map; [RequestBlockParallelTypeId] = parallelVariance; constructor(map) { this.map = map; } } /** @internal */ export const parallelCollectionEmpty = () => new ParallelImpl(HashMap.empty()); /** @internal */ export const parallelCollectionMake = (dataSource, blockedRequest) => new ParallelImpl(HashMap.make([dataSource, Chunk.of(blockedRequest)])); /** @internal */ export const parallelCollectionAdd = (self, blockedRequest) => 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, that) => 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 => HashMap.isEmpty(self.map); /** @internal */ export const parallelCollectionKeys = self => Array.from(HashMap.keys(self.map)); /** @internal */ export const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(HashMap.map(self.map, x => Chunk.of(x))); // 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 = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockSequential"); const sequentialVariance = { /* c8 ignore next */ _R: _ => _ }; class SequentialImpl { map; [SequentialCollectionTypeId] = sequentialVariance; constructor(map) { this.map = map; } } /** @internal */ export const sequentialCollectionMake = map => new SequentialImpl(map); /** @internal */ export const sequentialCollectionCombine = (self, that) => 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 => HashMap.isEmpty(self.map); /** @internal */ export const sequentialCollectionKeys = self => Array.from(HashMap.keys(self.map)); /** @internal */ export const sequentialCollectionToChunk = self => Array.from(self.map); //# sourceMappingURL=blockedRequests.js.map