Lorem Ipsum MCP Server

import * as Equal from "../../Equal.js" import { dual, pipe } from "../../Function.js" import * as Option from "../../Option.js" import * as Order from "../../Order.js" import type { Predicate } from "../../Predicate.js" import type * as STM from "../../STM.js" import type * as TArray from "../../TArray.js" import type * as TRef from "../../TRef.js" import * as core from "./core.js" import * as stm from "./stm.js" import * as tRef from "./tRef.js" /** @internal */ const TArraySymbolKey = "effect/TArray" /** @internal */ export const TArrayTypeId: TArray.TArrayTypeId = Symbol.for(TArraySymbolKey) as TArray.TArrayTypeId const tArrayVariance = { /* c8 ignore next */ _A: (_: any) => _ } /** @internal */ export class TArrayImpl<in out A> implements TArray.TArray<A> { readonly [TArrayTypeId] = tArrayVariance constructor(readonly chunk: Array<TRef.TRef<A>>) {} } /** @internal */ export const collectFirst = dual< <A, B>(pf: (a: A) => Option.Option<B>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<B>>, <A, B>(self: TArray.TArray<A>, pf: (a: A) => Option.Option<B>) => STM.STM<Option.Option<B>> >(2, (self, pf) => collectFirstSTM( self, (a) => pipe(pf(a), Option.map(core.succeed)) )) /** @internal */ export const collectFirstSTM = dual< <A, B, E, R>( pf: (a: A) => Option.Option<STM.STM<B, E, R>> ) => ( self: TArray.TArray<A> ) => STM.STM<Option.Option<B>, E, R>, <A, B, E, R>( self: TArray.TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>> ) => STM.STM<Option.Option<B>, E, R> >( 2, <A, B, E, R>(self: TArray.TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>>) => core.withSTMRuntime((runtime) => { let index = 0 let result: Option.Option<STM.STM<B, E, R>> = Option.none() while (Option.isNone(result) && index < self.chunk.length) { const element = pipe(self.chunk[index], tRef.unsafeGet(runtime.journal)) const option = pf(element) if (Option.isSome(option)) { result = option } index = index + 1 } return pipe( result, Option.match({ onNone: () => stm.succeedNone, onSome: core.map(Option.some) }) ) }) ) /** @internal */ export const contains = dual< <A>(value: A) => (self: TArray.TArray<A>) => STM.STM<boolean>, <A>(self: TArray.TArray<A>, value: A) => STM.STM<boolean> >(2, (self, value) => some(self, (a) => Equal.equals(a)(value))) /** @internal */ export const count = dual< <A>(predicate: Predicate<A>) => (self: TArray.TArray<A>) => STM.STM<number>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => STM.STM<number> >(2, (self, predicate) => reduce( self, 0, (n, a) => predicate(a) ? n + 1 : n )) /** @internal */ export const countSTM = dual< <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>) => (self: TArray.TArray<A>) => STM.STM<number, E, R>, <A, R, E>(self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>) => STM.STM<number, E, R> >(2, (self, predicate) => reduceSTM( self, 0, (n, a) => core.map(predicate(a), (bool) => bool ? n + 1 : n) )) /** @internal */ export const empty = <A>(): STM.STM<TArray.TArray<A>> => fromIterable<A>([]) /** @internal */ export const every = dual< <A>(predicate: Predicate<A>) => (self: TArray.TArray<A>) => STM.STM<boolean>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => STM.STM<boolean> >(2, (self, predicate) => stm.negate(some(self, (a) => !predicate(a)))) /** @internal */ export const everySTM = dual< <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>) => (self: TArray.TArray<A>) => STM.STM<boolean, E, R>, <A, R, E>(self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>) => STM.STM<boolean, E, R> >(2, (self, predicate) => core.map( countSTM(self, predicate), (count) => count === self.chunk.length )) /** @internal */ export const findFirst = dual< <A>(predicate: Predicate<A>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => STM.STM<Option.Option<A>> >(2, (self, predicate) => collectFirst(self, (a) => predicate(a) ? Option.some(a) : Option.none())) /** @internal */ export const findFirstIndex = dual< <A>(value: A) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>>, <A>(self: TArray.TArray<A>, value: A) => STM.STM<Option.Option<number>> >(2, (self, value) => findFirstIndexFrom(self, value, 0)) /** @internal */ export const findFirstIndexFrom = dual< <A>(value: A, from: number) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>>, <A>(self: TArray.TArray<A>, value: A, from: number) => STM.STM<Option.Option<number>> >(3, (self, value, from) => findFirstIndexWhereFrom( self, (a) => Equal.equals(a)(value), from )) /** @internal */ export const findFirstIndexWhere = dual< <A>(predicate: Predicate<A>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => STM.STM<Option.Option<number>> >(2, (self, predicate) => findFirstIndexWhereFrom(self, predicate, 0)) /** @internal */ export const findFirstIndexWhereFrom = dual< <A>( predicate: Predicate<A>, from: number ) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>, from: number) => STM.STM<Option.Option<number>> >(3, (self, predicate, from) => { if (from < 0) { return stm.succeedNone } return core.effect<never, Option.Option<number>>((journal) => { let index: number = from let found = false while (!found && index < self.chunk.length) { const element = tRef.unsafeGet(self.chunk[index], journal) found = predicate(element) index = index + 1 } if (found) { return Option.some(index - 1) } return Option.none() }) }) /** @internal */ export const findFirstIndexWhereSTM = dual< <A, R, E>( predicate: (value: A) => STM.STM<boolean, E, R> ) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>, E, R>, <A, R, E>( self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R> ) => STM.STM<Option.Option<number>, E, R> >(2, (self, predicate) => findFirstIndexWhereFromSTM(self, predicate, 0)) /** @internal */ export const findFirstIndexWhereFromSTM = dual< <A, R, E>( predicate: (value: A) => STM.STM<boolean, E, R>, from: number ) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>, E, R>, <A, R, E>( self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>, from: number ) => STM.STM<Option.Option<number>, E, R> >(3, <A, R, E>( self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>, from: number ) => { const forIndex = (index: number): STM.STM<Option.Option<number>, E, R> => index < self.chunk.length ? pipe( tRef.get(self.chunk[index]), core.flatMap(predicate), core.flatMap((bool) => bool ? core.succeed(Option.some(index)) : forIndex(index + 1) ) ) : stm.succeedNone return from < 0 ? stm.succeedNone : forIndex(from) }) /** @internal */ export const findFirstSTM = dual< <A, R, E>( predicate: (value: A) => STM.STM<boolean, E, R> ) => ( self: TArray.TArray<A> ) => STM.STM<Option.Option<A>, E, R>, <A, R, E>( self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R> ) => STM.STM<Option.Option<A>, E, R> >(2, <A, R, E>(self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>) => { const init = [Option.none() as Option.Option<A>, 0 as number] as const const cont = (state: readonly [Option.Option<A>, number]) => Option.isNone(state[0]) && state[1] < self.chunk.length - 1 return core.map( stm.iterate(init, { while: cont, body: (state) => { const index = state[1] return pipe( tRef.get(self.chunk[index]), core.flatMap((value) => core.map( predicate(value), (bool) => [bool ? Option.some(value) : Option.none(), index + 1] as const ) ) ) } }), (state) => state[0] ) }) /** @internal */ export const findLast = dual< <A>(predicate: Predicate<A>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => STM.STM<Option.Option<A>> >(2, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => core.effect<never, Option.Option<A>>((journal) => { let index = self.chunk.length - 1 let result: Option.Option<A> = Option.none() while (Option.isNone(result) && index >= 0) { const element = tRef.unsafeGet(self.chunk[index], journal) if (predicate(element)) { result = Option.some(element) } index = index - 1 } return result })) /** @internal */ export const findLastIndex = dual< <A>(value: A) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>>, <A>(self: TArray.TArray<A>, value: A) => STM.STM<Option.Option<number>> >(2, (self, value) => findLastIndexFrom(self, value, self.chunk.length - 1)) /** @internal */ export const findLastIndexFrom = dual< <A>(value: A, end: number) => (self: TArray.TArray<A>) => STM.STM<Option.Option<number>>, <A>(self: TArray.TArray<A>, value: A, end: number) => STM.STM<Option.Option<number>> >(3, (self, value, end) => { if (end >= self.chunk.length) { return stm.succeedNone } return core.effect<never, Option.Option<number>>((journal) => { let index: number = end let found = false while (!found && index >= 0) { const element = tRef.unsafeGet(self.chunk[index], journal) found = Equal.equals(element)(value) index = index - 1 } if (found) { return Option.some(index + 1) } return Option.none() }) }) /** @internal */ export const findLastSTM = dual< <A, R, E>( predicate: (value: A) => STM.STM<boolean, E, R> ) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>, E, R>, <A, R, E>( self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R> ) => STM.STM<Option.Option<A>, E, R> >(2, <A, R, E>(self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>) => { const init = [Option.none() as Option.Option<A>, self.chunk.length - 1] as const const cont = (state: readonly [Option.Option<A>, number]) => Option.isNone(state[0]) && state[1] >= 0 return core.map( stm.iterate(init, { while: cont, body: (state) => { const index = state[1] return pipe( tRef.get(self.chunk[index]), core.flatMap((value) => core.map( predicate(value), (bool) => [bool ? Option.some(value) : Option.none(), index - 1] as const ) ) ) } }), (state) => state[0] ) }) /** @internal */ export const forEach = dual< <A, R, E>(f: (value: A) => STM.STM<void, E, R>) => (self: TArray.TArray<A>) => STM.STM<void, E, R>, <A, R, E>(self: TArray.TArray<A>, f: (value: A) => STM.STM<void, E, R>) => STM.STM<void, E, R> >(2, (self, f) => reduceSTM(self, void 0 as void, (_, a) => f(a))) /** @internal */ export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<TArray.TArray<A>> => core.map( stm.forEach(iterable, tRef.make), (chunk) => new TArrayImpl(chunk) ) /** @internal */ export const get = dual< (index: number) => <A>(self: TArray.TArray<A>) => STM.STM<A>, <A>(self: TArray.TArray<A>, index: number) => STM.STM<A> >(2, (self, index) => { if (index < 0 || index >= self.chunk.length) { return core.dieMessage("Index out of bounds") } return tRef.get(self.chunk[index]) }) /** @internal */ export const headOption = <A>(self: TArray.TArray<A>): STM.STM<Option.Option<A>> => self.chunk.length === 0 ? core.succeed(Option.none()) : core.map(tRef.get(self.chunk[0]), Option.some) /** @internal */ export const lastOption = <A>(self: TArray.TArray<A>): STM.STM<Option.Option<A>> => self.chunk.length === 0 ? stm.succeedNone : core.map(tRef.get(self.chunk[self.chunk.length - 1]), Option.some) /** @internal */ export const make = <Elements extends [any, ...Array<any>]>( ...elements: Elements ): STM.STM<TArray.TArray<Elements[number]>> => fromIterable(elements) /** @internal */ export const maxOption = dual< <A>(order: Order.Order<A>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>>, <A>(self: TArray.TArray<A>, order: Order.Order<A>) => STM.STM<Option.Option<A>> >(2, (self, order) => { const greaterThan = Order.greaterThan(order) return reduceOption(self, (acc, curr) => greaterThan(acc)(curr) ? curr : acc) }) /** @internal */ export const minOption = dual< <A>(order: Order.Order<A>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>>, <A>(self: TArray.TArray<A>, order: Order.Order<A>) => STM.STM<Option.Option<A>> >(2, (self, order) => { const lessThan = Order.lessThan(order) return reduceOption(self, (acc, curr) => lessThan(acc)(curr) ? curr : acc) }) /** @internal */ export const reduce = dual< <Z, A>(zero: Z, f: (accumulator: Z, current: A) => Z) => (self: TArray.TArray<A>) => STM.STM<Z>, <Z, A>(self: TArray.TArray<A>, zero: Z, f: (accumulator: Z, current: A) => Z) => STM.STM<Z> >( 3, <Z, A>(self: TArray.TArray<A>, zero: Z, f: (accumulator: Z, current: A) => Z) => core.effect<never, Z>((journal) => { let index = 0 let result = zero while (index < self.chunk.length) { const element = tRef.unsafeGet(self.chunk[index], journal) result = f(result, element) index = index + 1 } return result }) ) /** @internal */ export const reduceOption = dual< <A>(f: (x: A, y: A) => A) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>>, <A>(self: TArray.TArray<A>, f: (x: A, y: A) => A) => STM.STM<Option.Option<A>> >( 2, <A>(self: TArray.TArray<A>, f: (x: A, y: A) => A) => core.effect<never, Option.Option<A>>((journal) => { let index = 0 let result: A | undefined = undefined while (index < self.chunk.length) { const element = tRef.unsafeGet(self.chunk[index], journal) result = result === undefined ? element : f(result, element) index = index + 1 } return Option.fromNullable(result) }) ) /** @internal */ export const reduceOptionSTM = dual< <A, R, E>(f: (x: A, y: A) => STM.STM<A, E, R>) => (self: TArray.TArray<A>) => STM.STM<Option.Option<A>, E, R>, <A, R, E>(self: TArray.TArray<A>, f: (x: A, y: A) => STM.STM<A, E, R>) => STM.STM<Option.Option<A>, E, R> >( 2, <A, R, E>(self: TArray.TArray<A>, f: (x: A, y: A) => STM.STM<A, E, R>) => reduceSTM(self, Option.none<A>(), (acc, curr) => Option.isSome(acc) ? core.map(f(acc.value, curr), Option.some) : stm.succeedSome(curr)) ) /** @internal */ export const reduceSTM = dual< <Z, A, R, E>( zero: Z, f: (accumulator: Z, current: A) => STM.STM<Z, E, R> ) => (self: TArray.TArray<A>) => STM.STM<Z, E, R>, <Z, A, R, E>( self: TArray.TArray<A>, zero: Z, f: (accumulator: Z, current: A) => STM.STM<Z, E, R> ) => STM.STM<Z, E, R> >(3, (self, zero, f) => core.flatMap( toArray(self), stm.reduce(zero, f) )) /** @internal */ export const size = <A>(self: TArray.TArray<A>): number => self.chunk.length /** @internal */ export const some = dual< <A>(predicate: Predicate<A>) => (self: TArray.TArray<A>) => STM.STM<boolean>, <A>(self: TArray.TArray<A>, predicate: Predicate<A>) => STM.STM<boolean> >(2, (self, predicate) => core.map( findFirst(self, predicate), Option.isSome )) /** @internal */ export const someSTM = dual< <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>) => (self: TArray.TArray<A>) => STM.STM<boolean, E, R>, <A, R, E>(self: TArray.TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>) => STM.STM<boolean, E, R> >(2, (self, predicate) => core.map(countSTM(self, predicate), (n) => n > 0)) /** @internal */ export const toArray = <A>(self: TArray.TArray<A>): STM.STM<Array<A>> => stm.forEach(self.chunk, tRef.get) /** @internal */ export const transform = dual< <A>(f: (value: A) => A) => (self: TArray.TArray<A>) => STM.STM<void>, <A>(self: TArray.TArray<A>, f: (value: A) => A) => STM.STM<void> >(2, (self, f) => core.effect<never, void>((journal) => { let index = 0 while (index < self.chunk.length) { const ref = self.chunk[index] tRef.unsafeSet(ref, f(tRef.unsafeGet(ref, journal)), journal) index = index + 1 } return void 0 })) /** @internal */ export const transformSTM = dual< <A, R, E>(f: (value: A) => STM.STM<A, E, R>) => (self: TArray.TArray<A>) => STM.STM<void, E, R>, <A, R, E>(self: TArray.TArray<A>, f: (value: A) => STM.STM<A, E, R>) => STM.STM<void, E, R> >(2, <A, R, E>(self: TArray.TArray<A>, f: (value: A) => STM.STM<A, E, R>) => core.flatMap( stm.forEach( self.chunk, (ref) => core.flatMap(tRef.get(ref), f) ), (chunk) => core.effect<never, void>((journal) => { const iterator = chunk[Symbol.iterator]() let index = 0 let next: IteratorResult<A> while ((next = iterator.next()) && !next.done) { tRef.unsafeSet(self.chunk[index], next.value, journal) index = index + 1 } return void 0 }) )) /** @internal */ export const update = dual< <A>(index: number, f: (value: A) => A) => (self: TArray.TArray<A>) => STM.STM<void>, <A>(self: TArray.TArray<A>, index: number, f: (value: A) => A) => STM.STM<void> >(3, (self, index, f) => { if (index < 0 || index >= self.chunk.length) { return core.dieMessage("Index out of bounds") } return tRef.update(self.chunk[index], f) }) /** @internal */ export const updateSTM = dual< <A, R, E>(index: number, f: (value: A) => STM.STM<A, E, R>) => (self: TArray.TArray<A>) => STM.STM<void, E, R>, <A, R, E>(self: TArray.TArray<A>, index: number, f: (value: A) => STM.STM<A, E, R>) => STM.STM<void, E, R> >(3, (self, index, f) => { if (index < 0 || index >= self.chunk.length) { return core.dieMessage("Index out of bounds") } return pipe( tRef.get(self.chunk[index]), core.flatMap(f), core.flatMap((updated) => tRef.set(self.chunk[index], updated)) ) })