@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/stm/tDeferred.ts

@@ -1,81 +0,0 @@
-import * as Either from "../../Either.js"
-import { dual } from "../../Function.js"
-import * as Option from "../../Option.js"
-import type * as STM from "../../STM.js"
-import type * as TDeferred from "../../TDeferred.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 TDeferredSymbolKey = "effect/TDeferred"
-
-/** @internal */
-export const TDeferredTypeId: TDeferred.TDeferredTypeId = Symbol.for(
-  TDeferredSymbolKey
-) as TDeferred.TDeferredTypeId
-
-/** @internal */
-const tDeferredVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _,
-  /* c8 ignore next */
-  _E: (_: any) => _
-}
-
-/** @internal */
-class TDeferredImpl<in out A, in out E = never> implements TDeferred.TDeferred<A, E> {
-  readonly [TDeferredTypeId] = tDeferredVariance
-  constructor(readonly ref: TRef.TRef<Option.Option<Either.Either<A, E>>>) {}
-}
-
-/** @internal */
-export const _await = <A, E>(self: TDeferred.TDeferred<A, E>): STM.STM<A, E> =>
-  stm.flatten(
-    stm.collect(tRef.get(self.ref), (option) =>
-      Option.isSome(option) ?
-        Option.some(stm.fromEither(option.value)) :
-        Option.none())
-  )
-
-/** @internal */
-export const done = dual<
-  <A, E>(either: Either.Either<A, E>) => (self: TDeferred.TDeferred<A, E>) => STM.STM<boolean>,
-  <A, E>(self: TDeferred.TDeferred<A, E>, either: Either.Either<A, E>) => STM.STM<boolean>
->(2, (self, either) =>
-  core.flatMap(
-    tRef.get(self.ref),
-    Option.match({
-      onNone: () =>
-        core.zipRight(
-          tRef.set(self.ref, Option.some(either)),
-          core.succeed(true)
-        ),
-      onSome: () => core.succeed(false)
-    })
-  ))
-
-/** @internal */
-export const fail = dual<
-  <E>(error: E) => <A>(self: TDeferred.TDeferred<A, E>) => STM.STM<boolean>,
-  <A, E>(self: TDeferred.TDeferred<A, E>, error: E) => STM.STM<boolean>
->(2, (self, error) => done(self, Either.left(error)))
-
-/** @internal */
-export const make = <A, E = never>(): STM.STM<TDeferred.TDeferred<A, E>> =>
-  core.map(
-    tRef.make<Option.Option<Either.Either<A, E>>>(Option.none()),
-    (ref) => new TDeferredImpl(ref)
-  )
-
-/** @internal */
-export const poll = <A, E>(
-  self: TDeferred.TDeferred<A, E>
-): STM.STM<Option.Option<Either.Either<A, E>>> => tRef.get(self.ref)
-
-/** @internal */
-export const succeed = dual<
-  <A>(value: A) => <E>(self: TDeferred.TDeferred<A, E>) => STM.STM<boolean>,
-  <A, E>(self: TDeferred.TDeferred<A, E>, value: A) => STM.STM<boolean>
->(2, (self, value) => done(self, Either.right(value)))

package/src/internal/stm/tExit.ts

@@ -1,190 +0,0 @@
-import * as Equal from "../../Equal.js"
-import type * as FiberId from "../../FiberId.js"
-import { pipe } from "../../Function.js"
-import * as Hash from "../../Hash.js"
-import { hasProperty } from "../../Predicate.js"
-import type * as Types from "../../Types.js"
-import * as OpCodes from "./opCodes/tExit.js"
-
-/** @internal */
-const TExitSymbolKey = "effect/TExit"
-
-/** @internal */
-export const TExitTypeId = Symbol.for(TExitSymbolKey)
-
-/** @internal */
-export type TExitTypeId = typeof TExitTypeId
-
-/** @internal */
-export type TExit<A, E = never> = Fail<E> | Die | Interrupt | Succeed<A> | Retry
-
-/** @internal */
-export declare namespace TExit {
-  /** @internal */
-  export interface Variance<out A, out E> {
-    readonly [TExitTypeId]: {
-      readonly _A: Types.Covariant<A>
-      readonly _E: Types.Covariant<E>
-    }
-  }
-}
-
-const variance = {
-  /* c8 ignore next */
-  _A: (_: never) => _,
-  /* c8 ignore next */
-  _E: (_: never) => _
-}
-
-/** @internal */
-export interface Fail<out E> extends TExit.Variance<never, E>, Equal.Equal {
-  readonly _tag: OpCodes.OP_FAIL
-  readonly error: E
-}
-
-/** @internal */
-export interface Die extends TExit.Variance<never, never>, Equal.Equal {
-  readonly _tag: OpCodes.OP_DIE
-  readonly defect: unknown
-}
-
-/** @internal */
-export interface Interrupt extends TExit.Variance<never, never>, Equal.Equal {
-  readonly _tag: OpCodes.OP_INTERRUPT
-  readonly fiberId: FiberId.FiberId
-}
-
-/** @internal */
-export interface Succeed<out A> extends TExit.Variance<A, never>, Equal.Equal {
-  readonly _tag: OpCodes.OP_SUCCEED
-  readonly value: A
-}
-
-/** @internal */
-export interface Retry extends TExit.Variance<never, never>, Equal.Equal {
-  readonly _tag: OpCodes.OP_RETRY
-}
-
-/** @internal */
-export const isExit = (u: unknown): u is TExit<unknown, unknown> => hasProperty(u, TExitTypeId)
-
-/** @internal */
-export const isFail = <A, E>(self: TExit<A, E>): self is Fail<E> => {
-  return self._tag === OpCodes.OP_FAIL
-}
-
-/** @internal */
-export const isDie = <A, E>(self: TExit<A, E>): self is Die => {
-  return self._tag === OpCodes.OP_DIE
-}
-
-/** @internal */
-export const isInterrupt = <A, E>(self: TExit<A, E>): self is Interrupt => {
-  return self._tag === OpCodes.OP_INTERRUPT
-}
-
-/** @internal */
-export const isSuccess = <A, E>(self: TExit<A, E>): self is Succeed<A> => {
-  return self._tag === OpCodes.OP_SUCCEED
-}
-
-/** @internal */
-export const isRetry = <A, E>(self: TExit<A, E>): self is Retry => {
-  return self._tag === OpCodes.OP_RETRY
-}
-
-/** @internal */
-export const fail = <E>(error: E): TExit<never, E> => ({
-  [TExitTypeId]: variance,
-  _tag: OpCodes.OP_FAIL,
-  error,
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(TExitSymbolKey),
-      Hash.combine(Hash.hash(OpCodes.OP_FAIL)),
-      Hash.combine(Hash.hash(error)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](that: unknown): boolean {
-    return isExit(that) && that._tag === OpCodes.OP_FAIL && Equal.equals(error, that.error)
-  }
-})
-
-/** @internal */
-export const die = (defect: unknown): TExit<never> => ({
-  [TExitTypeId]: variance,
-  _tag: OpCodes.OP_DIE,
-  defect,
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(TExitSymbolKey),
-      Hash.combine(Hash.hash(OpCodes.OP_DIE)),
-      Hash.combine(Hash.hash(defect)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](that: unknown): boolean {
-    return isExit(that) && that._tag === OpCodes.OP_DIE && Equal.equals(defect, that.defect)
-  }
-})
-
-/** @internal */
-export const interrupt = (fiberId: FiberId.FiberId): TExit<never> => ({
-  [TExitTypeId]: variance,
-  _tag: OpCodes.OP_INTERRUPT,
-  fiberId,
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(TExitSymbolKey),
-      Hash.combine(Hash.hash(OpCodes.OP_INTERRUPT)),
-      Hash.combine(Hash.hash(fiberId)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](that: unknown): boolean {
-    return isExit(that) && that._tag === OpCodes.OP_INTERRUPT && Equal.equals(fiberId, that.fiberId)
-  }
-})
-
-/** @internal */
-export const succeed = <A>(value: A): TExit<A> => ({
-  [TExitTypeId]: variance,
-  _tag: OpCodes.OP_SUCCEED,
-  value,
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(TExitSymbolKey),
-      Hash.combine(Hash.hash(OpCodes.OP_SUCCEED)),
-      Hash.combine(Hash.hash(value)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](that: unknown): boolean {
-    return isExit(that) && that._tag === OpCodes.OP_SUCCEED && Equal.equals(value, that.value)
-  }
-})
-
-const retryHash = pipe(
-  Hash.hash(TExitSymbolKey),
-  Hash.combine(Hash.hash(OpCodes.OP_RETRY)),
-  Hash.combine(Hash.hash("retry"))
-)
-
-/** @internal */
-export const retry: TExit<never> = {
-  [TExitTypeId]: variance,
-  _tag: OpCodes.OP_RETRY,
-  [Hash.symbol](): number {
-    return retryHash
-  },
-  [Equal.symbol](that: unknown): boolean {
-    return isExit(that) && isRetry(that)
-  }
-}
-
-const void_: TExit<void> = succeed(undefined)
-export {
-  /** @internal */
-  void_ as void
-}