Lorem Ipsum MCP Server

import * as Deferred from "../../Deferred.js" import * as Effect from "../../Effect.js" import { dual, pipe } from "../../Function.js" import * as Option from "../../Option.js" import * as Ref from "../../Ref.js" /** @internal */ export const HandoffTypeId = Symbol.for("effect/Stream/Handoff") /** @internal */ export type HandoffTypeId = typeof HandoffTypeId /** * A synchronous queue-like abstraction that allows a producer to offer an * element and wait for it to be taken, and allows a consumer to wait for an * element to be available. * * @internal */ export interface Handoff<in out A> extends Handoff.Variance<A> { readonly ref: Ref.Ref<Handoff.State<A>> } /** @internal */ export const OP_HANDOFF_STATE_EMPTY = "Empty" as const /** @internal */ export type OP_HANDOFF_STATE_EMPTY = typeof OP_HANDOFF_STATE_EMPTY /** @internal */ export const OP_HANDOFF_STATE_FULL = "Full" as const /** @internal */ export type OP_HANDOFF_STATE_FULL = typeof OP_HANDOFF_STATE_FULL /** @internal */ export declare namespace Handoff { /** @internal */ export interface Variance<in out A> { readonly [HandoffTypeId]: { readonly _A: (_: A) => A } } /** @internal */ export type State<A> = Empty | Full<A> /** @internal */ export interface Empty { readonly _tag: OP_HANDOFF_STATE_EMPTY readonly notifyConsumer: Deferred.Deferred<void> } /** @internal */ export interface Full<out A> { readonly _tag: OP_HANDOFF_STATE_FULL readonly value: A readonly notifyProducer: Deferred.Deferred<void> } } /** @internal */ const handoffStateEmpty = <A>(notifyConsumer: Deferred.Deferred<void>): Handoff.State<A> => ({ _tag: OP_HANDOFF_STATE_EMPTY, notifyConsumer }) /** @internal */ const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<void>): Handoff.State<A> => ({ _tag: OP_HANDOFF_STATE_FULL, value, notifyProducer }) /** @internal */ const handoffStateMatch = <A, Z>( onEmpty: (notifyConsumer: Deferred.Deferred<void>) => Z, onFull: (value: A, notifyProducer: Deferred.Deferred<void>) => Z ) => { return (self: Handoff.State<A>): Z => { switch (self._tag) { case OP_HANDOFF_STATE_EMPTY: { return onEmpty(self.notifyConsumer) } case OP_HANDOFF_STATE_FULL: { return onFull(self.value, self.notifyProducer) } } } } const handoffVariance = { /* c8 ignore next */ _A: (_: any) => _ } /** @internal */ export const make = <A>(): Effect.Effect<Handoff<A>> => pipe( Deferred.make<void>(), Effect.flatMap((deferred) => Ref.make(handoffStateEmpty<A>(deferred))), Effect.map((ref): Handoff<A> => ({ [HandoffTypeId]: handoffVariance, ref })) ) /** @internal */ export const offer = dual< <A>(value: A) => (self: Handoff<A>) => Effect.Effect<void>, <A>(self: Handoff<A>, value: A) => Effect.Effect<void> >(2, (self, value): Effect.Effect<void> => { return Effect.flatMap(Deferred.make<void>(), (deferred) => Effect.flatten( Ref.modify(self.ref, (state) => pipe( state, handoffStateMatch( (notifyConsumer) => [ Effect.zipRight( Deferred.succeed(notifyConsumer, void 0), Deferred.await(deferred) ), handoffStateFull(value, deferred) ], (_, notifyProducer) => [ Effect.flatMap( Deferred.await(notifyProducer), () => pipe(self, offer(value)) ), state ] ) )) )) }) /** @internal */ export const take = <A>(self: Handoff<A>): Effect.Effect<A> => Effect.flatMap(Deferred.make<void>(), (deferred) => Effect.flatten( Ref.modify(self.ref, (state) => pipe( state, handoffStateMatch( (notifyConsumer) => [ Effect.flatMap( Deferred.await(notifyConsumer), () => take(self) ), state ] as const, (value, notifyProducer) => [ Effect.as( Deferred.succeed(notifyProducer, void 0), value ), handoffStateEmpty<A>(deferred) ] ) )) )) /** @internal */ export const poll = <A>(self: Handoff<A>): Effect.Effect<Option.Option<A>> => Effect.flatMap(Deferred.make<void>(), (deferred) => Effect.flatten( Ref.modify(self.ref, (state) => pipe( state, handoffStateMatch( () => [ Effect.succeed(Option.none<A>()), state ] as const, (value, notifyProducer) => [ Effect.as( Deferred.succeed(notifyProducer, void 0), Option.some(value) ), handoffStateEmpty<A>(deferred) ] ) )) ))