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

package/src/internal/stm/stmState.ts

@@ -0,0 +1,136 @@
+import * as Equal from "../../Equal.js"
+import * as Exit from "../../Exit.js"
+import { pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import { hasProperty } from "../../Predicate.js"
+import * as OpCodes from "./opCodes/stmState.js"
+import * as TExitOpCodes from "./opCodes/tExit.js"
+import type * as TExit from "./tExit.js"
+
+/** @internal */
+const STMStateSymbolKey = "effect/STM/State"
+
+/** @internal */
+export const STMStateTypeId = Symbol.for(STMStateSymbolKey)
+
+/** @internal */
+export type STMStateTypeId = typeof STMStateTypeId
+
+/** @internal */
+export type STMState<A, E = never> = Done<A, E> | Interrupted | Running
+
+/** @internal */
+export interface Done<out A, out E = never> extends Equal.Equal {
+  readonly [STMStateTypeId]: STMStateTypeId
+  readonly _tag: OpCodes.OP_DONE
+  readonly exit: Exit.Exit<A, E>
+}
+
+/** @internal */
+export interface Interrupted extends Equal.Equal {
+  readonly [STMStateTypeId]: STMStateTypeId
+  readonly _tag: OpCodes.OP_INTERRUPTED
+}
+
+/** @internal */
+export interface Running extends Equal.Equal {
+  readonly [STMStateTypeId]: STMStateTypeId
+  readonly _tag: OpCodes.OP_RUNNING
+}
+
+/** @internal */
+export const isSTMState = (u: unknown): u is STMState<unknown, unknown> => hasProperty(u, STMStateTypeId)
+
+/** @internal */
+export const isRunning = <A, E>(self: STMState<A, E>): self is Running => {
+  return self._tag === OpCodes.OP_RUNNING
+}
+
+/** @internal */
+export const isDone = <A, E>(self: STMState<A, E>): self is Done<A, E> => {
+  return self._tag === OpCodes.OP_DONE
+}
+
+/** @internal */
+export const isInterrupted = <A, E>(self: STMState<A, E>): self is Interrupted => {
+  return self._tag === OpCodes.OP_INTERRUPTED
+}
+
+/** @internal */
+export const done = <A, E>(exit: Exit.Exit<A, E>): STMState<A, E> => {
+  return {
+    [STMStateTypeId]: STMStateTypeId,
+    _tag: OpCodes.OP_DONE,
+    exit,
+    [Hash.symbol](): number {
+      return pipe(
+        Hash.hash(STMStateSymbolKey),
+        Hash.combine(Hash.hash(OpCodes.OP_DONE)),
+        Hash.combine(Hash.hash(exit)),
+        Hash.cached(this)
+      )
+    },
+    [Equal.symbol](that: unknown): boolean {
+      return isSTMState(that) && that._tag === OpCodes.OP_DONE && Equal.equals(exit, that.exit)
+    }
+  }
+}
+
+const interruptedHash = pipe(
+  Hash.hash(STMStateSymbolKey),
+  Hash.combine(Hash.hash(OpCodes.OP_INTERRUPTED)),
+  Hash.combine(Hash.hash("interrupted"))
+)
+
+/** @internal */
+export const interrupted: STMState<never> = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OpCodes.OP_INTERRUPTED,
+  [Hash.symbol](): number {
+    return interruptedHash
+  },
+  [Equal.symbol](that: unknown): boolean {
+    return isSTMState(that) && that._tag === OpCodes.OP_INTERRUPTED
+  }
+}
+
+const runningHash = pipe(
+  Hash.hash(STMStateSymbolKey),
+  Hash.combine(Hash.hash(OpCodes.OP_RUNNING)),
+  Hash.combine(Hash.hash("running"))
+)
+
+/** @internal */
+export const running: STMState<never> = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OpCodes.OP_RUNNING,
+  [Hash.symbol](): number {
+    return runningHash
+  },
+  [Equal.symbol](that: unknown): boolean {
+    return isSTMState(that) && that._tag === OpCodes.OP_RUNNING
+  }
+}
+
+/** @internal */
+export const fromTExit = <A, E>(tExit: TExit.TExit<A, E>): STMState<A, E> => {
+  switch (tExit._tag) {
+    case TExitOpCodes.OP_FAIL: {
+      return done(Exit.fail(tExit.error))
+    }
+    case TExitOpCodes.OP_DIE: {
+      return done(Exit.die(tExit.defect))
+    }
+    case TExitOpCodes.OP_INTERRUPT: {
+      return done(Exit.interrupt(tExit.fiberId))
+    }
+    case TExitOpCodes.OP_SUCCEED: {
+      return done(Exit.succeed(tExit.value))
+    }
+    case TExitOpCodes.OP_RETRY: {
+      throw new Error(
+        "BUG: STM.STMState.fromTExit - please report an issue at https://github.com/Effect-TS/effect/issues"
+      )
+    }
+  }
+}

package/src/internal/stm/tArray.ts

@@ -0,0 +1,550 @@
+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))
+  )
+})