Lorem Ipsum MCP Server

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]: {} } }