effect 2.0.0-next.38 → 2.0.0-next.39

package/internal/stm/opCodes/stm.esm.js

@@ -0,0 +1,56 @@
+/** @internal */
+const OP_WITH_STM_RUNTIME = "WithSTMRuntime";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_FAILURE = "OnFailure";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_RETRY = "OnRetry";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_SUCCESS = "OnSuccess";
+
+/** @internal */
+
+/** @internal */
+const OP_PROVIDE = "Provide";
+
+/** @internal */
+
+/** @internal */
+const OP_SYNC = "Sync";
+
+/** @internal */
+
+/** @internal */
+const OP_SUCCEED = "Succeed";
+
+/** @internal */
+
+/** @internal */
+const OP_RETRY = "Retry";
+
+/** @internal */
+
+/** @internal */
+const OP_FAIL = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_DIE = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+
+/** @internal */
+
+export { OP_DIE, OP_FAIL, OP_INTERRUPT, OP_ON_FAILURE, OP_ON_RETRY, OP_ON_SUCCESS, OP_PROVIDE, OP_RETRY, OP_SUCCEED, OP_SYNC, OP_WITH_STM_RUNTIME };

package/internal/stm/opCodes/stmState.esm.js

@@ -0,0 +1,16 @@
+/** @internal */
+const OP_DONE = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPTED = "Interrupted";
+
+/** @internal */
+
+/** @internal */
+const OP_RUNNING = "Running";
+
+/** @internal */
+
+export { OP_DONE, OP_INTERRUPTED, OP_RUNNING };

package/internal/stm/opCodes/strategy.esm.js

@@ -0,0 +1,16 @@
+/** @internal */
+const OP_BACKPRESSURE_STRATEGY = "BackPressure";
+
+/** @internal */
+
+/** @internal */
+const OP_DROPPING_STRATEGY = "Dropping";
+
+/** @internal */
+
+/** @internal */
+const OP_SLIDING_STRATEGY = "Sliding";
+
+/** @internal */
+
+export { OP_BACKPRESSURE_STRATEGY, OP_DROPPING_STRATEGY, OP_SLIDING_STRATEGY };

package/internal/stm/opCodes/tExit.esm.js

@@ -0,0 +1,26 @@
+/** @internal */
+const OP_FAIL = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_DIE = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+
+/** @internal */
+
+/** @internal */
+const OP_SUCCEED = "Succeed";
+
+/** @internal */
+
+/** @internal */
+const OP_RETRY = "Retry";
+
+/** @internal */
+
+export { OP_DIE, OP_FAIL, OP_INTERRUPT, OP_RETRY, OP_SUCCEED };

package/internal/stm/opCodes/tryCommit.esm.js

@@ -0,0 +1,11 @@
+/** @internal */
+const OP_DONE = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_SUSPEND = "Suspend";
+
+/** @internal */
+
+export { OP_DONE, OP_SUSPEND };

package/internal/stm/stm/entry.esm.js

@@ -0,0 +1,47 @@
+import { Versioned } from './versioned.esm.js';
+
+/** @internal */
+
+/** @internal */
+const make = (ref, isNew) => ({
+  ref,
+  isNew,
+  isChanged: false,
+  expected: ref.versioned,
+  newValue: ref.versioned.value
+});
+const unsafeGet = self => {
+  return self.newValue;
+};
+
+/** @internal */
+const unsafeSet = (self, value) => {
+  self.isChanged = true;
+  self.newValue = value;
+};
+
+/** @internal */
+const commit = self => {
+  self.ref.versioned = new Versioned(self.newValue);
+};
+
+/** @internal */
+const copy = self => ({
+  ref: self.ref,
+  isNew: self.isNew,
+  isChanged: self.isChanged,
+  expected: self.expected,
+  newValue: self.newValue
+});
+
+/** @internal */
+const isInvalid = self => {
+  return self.ref.versioned !== self.expected;
+};
+
+/** @internal */
+const isChanged = self => {
+  return self.isChanged;
+};
+
+export { commit, copy, isChanged, isInvalid, make, unsafeGet, unsafeSet };

package/internal/stm/stm/journal.esm.js

@@ -0,0 +1,96 @@
+import { commit, isInvalid, isChanged, copy } from './entry.esm.js';
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisInvalid = "Invalid";
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisReadWrite = "ReadWrite";
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisReadOnly = "ReadOnly";
+
+/** @internal */
+
+/** @internal */
+const commitJournal = journal => {
+  for (const entry of journal) {
+    commit(entry[1]);
+  }
+};
+
+/**
+ * Analyzes the journal, determining whether it is valid and whether it is
+ * read only in a single pass. Note that information on whether the
+ * journal is read only will only be accurate if the journal is valid, due
+ * to short-circuiting that occurs on an invalid journal.
+ *
+ * @internal
+ */
+const analyzeJournal = journal => {
+  let val = JournalAnalysisReadOnly;
+  for (const [, entry] of journal) {
+    val = isInvalid(entry) ? JournalAnalysisInvalid : isChanged(entry) ? JournalAnalysisReadWrite : val;
+    if (val === JournalAnalysisInvalid) {
+      return val;
+    }
+  }
+  return val;
+};
+
+/** @internal */
+const prepareResetJournal = journal => {
+  const saved = new Map();
+  for (const entry of journal) {
+    saved.set(entry[0], copy(entry[1]));
+  }
+  return () => {
+    journal.clear();
+    for (const entry of saved) {
+      journal.set(entry[0], entry[1]);
+    }
+  };
+};
+
+/** @internal */
+const collectTodos = journal => {
+  const allTodos = new Map();
+  for (const [, entry] of journal) {
+    for (const todo of entry.ref.todos) {
+      allTodos.set(todo[0], todo[1]);
+    }
+    entry.ref.todos = new Map();
+  }
+  return allTodos;
+};
+
+/** @internal */
+const execTodos = todos => {
+  const todosSorted = Array.from(todos.entries()).sort((x, y) => x[0] - y[0]);
+  for (const [_, todo] of todosSorted) {
+    todo();
+  }
+};
+
+/** @internal */
+const addTodo = (txnId, journal, todoEffect) => {
+  let added = false;
+  for (const [, entry] of journal) {
+    if (!entry.ref.todos.has(txnId)) {
+      entry.ref.todos.set(txnId, todoEffect);
+      added = true;
+    }
+  }
+  return added;
+};
+
+export { JournalAnalysisInvalid, JournalAnalysisReadOnly, JournalAnalysisReadWrite, addTodo, analyzeJournal, collectTodos, commitJournal, execTodos, prepareResetJournal };

package/internal/stm/stm/stmState.esm.js

@@ -0,0 +1,104 @@
+import { symbol as symbol$1, equals } from '../../../Equal/dist/effect-Equal.esm.js';
+import { succeed, interrupt, die, fail } from '../../../Exit/dist/effect-Exit.esm.js';
+import { pipe } from '../../../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash } from '../../../Hash/dist/effect-Hash.esm.js';
+import { OP_DONE, OP_RUNNING, OP_INTERRUPTED } from '../opCodes/stmState.esm.js';
+import { OP_RETRY, OP_SUCCEED, OP_INTERRUPT, OP_DIE, OP_FAIL } from '../opCodes/tExit.esm.js';
+
+/** @internal */
+const STMStateSymbolKey = "effect/STM/State";
+
+/** @internal */
+const STMStateTypeId = /*#__PURE__*/Symbol.for(STMStateSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isSTMState = u => {
+  return typeof u === "object" && u != null && STMStateTypeId in u;
+};
+
+/** @internal */
+const isRunning = self => {
+  return self._tag === OP_RUNNING;
+};
+
+/** @internal */
+const isDone = self => {
+  return self._tag === OP_DONE;
+};
+
+/** @internal */
+const done = exit => {
+  return {
+    [STMStateTypeId]: STMStateTypeId,
+    _tag: OP_DONE,
+    exit,
+    [symbol]() {
+      return pipe(hash(STMStateSymbolKey), combine(hash(OP_DONE)), combine(hash(exit)));
+    },
+    [symbol$1](that) {
+      return isSTMState(that) && that._tag === OP_DONE && equals(exit, that.exit);
+    }
+  };
+};
+
+/** @internal */
+const interrupted = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OP_INTERRUPTED,
+  [symbol]() {
+    return pipe(hash(STMStateSymbolKey), combine(hash(OP_INTERRUPTED)), combine(hash("interrupted")));
+  },
+  [symbol$1](that) {
+    return isSTMState(that) && that._tag === OP_INTERRUPTED;
+  }
+};
+
+/** @internal */
+const running = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OP_RUNNING,
+  [symbol]() {
+    return pipe(hash(STMStateSymbolKey), combine(hash(OP_RUNNING)), combine(hash("running")));
+  },
+  [symbol$1](that) {
+    return isSTMState(that) && that._tag === OP_RUNNING;
+  }
+};
+
+/** @internal */
+const fromTExit = tExit => {
+  switch (tExit._tag) {
+    case OP_FAIL:
+      {
+        return done(fail(tExit.error));
+      }
+    case OP_DIE:
+      {
+        return done(die(tExit.defect));
+      }
+    case OP_INTERRUPT:
+      {
+        return done(interrupt(tExit.fiberId));
+      }
+    case OP_SUCCEED:
+      {
+        return done(succeed(tExit.value));
+      }
+    case OP_RETRY:
+      {
+        throw new Error("BUG: STM.STMState.fromTExit - please report an issue at https://github.com/Effect-TS/io/issues");
+      }
+  }
+};
+
+export { STMStateTypeId, done, fromTExit, interrupted, isDone, isRunning, isSTMState, running };

package/internal/stm/stm/tExit.esm.js

@@ -0,0 +1,113 @@
+import { symbol as symbol$1, equals } from '../../../Equal/dist/effect-Equal.esm.js';
+import { pipe } from '../../../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash } from '../../../Hash/dist/effect-Hash.esm.js';
+import { OP_SUCCEED, OP_FAIL, OP_DIE, OP_INTERRUPT, OP_RETRY } from '../opCodes/tExit.esm.js';
+
+/** @internal */
+const TExitSymbolKey = "effect/TExit";
+
+/** @internal */
+const TExitTypeId = /*#__PURE__*/Symbol.for(TExitSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const variance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isExit = u => {
+  return typeof u === "object" && u != null && TExitTypeId in u;
+};
+
+/** @internal */
+const isSuccess = self => {
+  return self._tag === OP_SUCCEED;
+};
+
+/** @internal */
+const isRetry = self => {
+  return self._tag === OP_RETRY;
+};
+
+/** @internal */
+const fail = error => ({
+  [TExitTypeId]: variance,
+  _tag: OP_FAIL,
+  error,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_FAIL)), combine(hash(error)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_FAIL && equals(error, that.error);
+  }
+});
+
+/** @internal */
+const die = defect => ({
+  [TExitTypeId]: variance,
+  _tag: OP_DIE,
+  defect,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_DIE)), combine(hash(defect)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_DIE && equals(defect, that.defect);
+  }
+});
+
+/** @internal */
+const interrupt = fiberId => ({
+  [TExitTypeId]: variance,
+  _tag: OP_INTERRUPT,
+  fiberId,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_INTERRUPT)), combine(hash(fiberId)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_INTERRUPT && equals(fiberId, that.fiberId);
+  }
+});
+
+/** @internal */
+const succeed = value => ({
+  [TExitTypeId]: variance,
+  _tag: OP_SUCCEED,
+  value,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_SUCCEED)), combine(hash(value)));
+  },
+  [symbol$1](that) {
+    return isExit(that) && that._tag === OP_SUCCEED && equals(value, that.value);
+  }
+});
+
+/** @internal */
+const retry = {
+  [TExitTypeId]: variance,
+  _tag: OP_RETRY,
+  [symbol]() {
+    return pipe(hash(TExitSymbolKey), combine(hash(OP_RETRY)), combine(hash("retry")));
+  },
+  [symbol$1](that) {
+    return isExit(that) && isRetry(that);
+  }
+};
+
+export { TExitTypeId, die, fail, interrupt, isExit, isRetry, isSuccess, retry, succeed };

package/internal/stm/stm/tryCommit.esm.js

@@ -0,0 +1,25 @@
+import { OP_DONE, OP_SUSPEND } from '../opCodes/tryCommit.esm.js';
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const done = exit => {
+  return {
+    _tag: OP_DONE,
+    exit
+  };
+};
+
+/** @internal */
+const suspend = journal => {
+  return {
+    _tag: OP_SUSPEND,
+    journal
+  };
+};
+
+export { done, suspend };

package/internal/stm/stm/txnId.esm.js

@@ -0,0 +1,15 @@
+/** @internal */
+
+/** @internal */
+const txnCounter = {
+  ref: 0
+};
+
+/** @internal */
+const make = () => {
+  const newId = txnCounter.ref + 1;
+  txnCounter.ref = newId;
+  return newId;
+};
+
+export { make };

package/internal/stm/stm/versioned.esm.js

@@ -0,0 +1,8 @@
+/** @internal */
+class Versioned {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+export { Versioned };

package/{dist/stm-6937f6f2.esm.js → internal/stm/stm.esm.js}

@@ -1,16 +1,18 @@
-import { p as parallel } from './Cause-5946c7a3.esm.js';
-import { c as append, e as empty } from './Chunk-4c1f4599.esm.js';
-import { m as merge$1, b as add } from './Context-c41aa832.esm.js';
-import { u as uninterruptibleMask, m as matchCauseEffect, f as failCause, b as as$1, d as flatten$1 } from './Effect-ee05a487.esm.js';
-import { l as left, r as right } from './Either-aa46c018.esm.js';
-import { c as isSuccess$1 } from './Exit-666b4f01.esm.js';
-import { d as dual, p as pipe, b as constVoid, i as identity, c as constTrue, a as constFalse } from './Function-12511160.esm.js';
-import { T as partitionMap } from './core-64ab7ff5.esm.js';
-import { S as SingleShotGen } from './core-effect-57445976.esm.js';
-import { A as isDone, B as unsafeAtomically, r as map, n as flatMap, c as catchAll, k as fail, u as succeed, o as matchSTM, t as retry, a as commit, v as sync, C as effect, y as zipWith, h as dieSync, g as dieMessage, l as failSync, i as isSTM, f as die, s as orTry, m as mapInputContext, e as contextWithSTM, x as zipRight, D as running, E as interrupted, F as done, G as prepareResetJournal } from './core-f6cae6d7.esm.js';
-import { s as some$1, g as getOrElse, m as map$1, i as isSome, b as match$1, n as none$1 } from './Option-df40d2b9.esm.js';
-import { a as isIterable } from './Predicate-6b61b95b.esm.js';
-import { W as isNonEmptyArray, f as fromIterable } from './ReadonlyArray-0a71b226.esm.js';
+import { parallel } from '../../Cause/dist/effect-Cause.esm.js';
+import { append, empty } from '../../Chunk/dist/effect-Chunk.esm.js';
+import { merge as merge$1, add } from '../../Context/dist/effect-Context.esm.js';
+import { uninterruptibleMask, matchCauseEffect, failCause, as as as$1, flatten as flatten$1 } from '../../Effect/dist/effect-Effect.esm.js';
+import { left, right } from '../../Either/dist/effect-Either.esm.js';
+import { isSuccess as isSuccess$1 } from '../../Exit/dist/effect-Exit.esm.js';
+import { dual, pipe, constVoid, identity, constTrue, constFalse } from '../../Function/dist/effect-Function.esm.js';
+import { partitionMap } from '../core.esm.js';
+import { SingleShotGen } from '../singleShotGen.esm.js';
+import { unsafeAtomically, map, flatMap, catchAll, fail, succeed, matchSTM, retry, commit, sync, effect, zipWith, dieSync, dieMessage, failSync, isSTM, die, orTry, mapInputContext, contextWithSTM, zipRight } from './core.esm.js';
+import { prepareResetJournal } from './stm/journal.esm.js';
+import { isDone, running, interrupted, done } from './stm/stmState.esm.js';
+import { some as some$1, getOrElse, map as map$1, isSome, match as match$1, none as none$1 } from '../../Option/dist/effect-Option.esm.js';
+import { isIterable } from '../../Predicate/dist/effect-Predicate.esm.js';
+import { isNonEmptyArray, fromIterable } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
 const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) => uninterruptibleMask(restore => {
@@ -579,4 +581,4 @@ const when = /*#__PURE__*/dual(2, (self, predicate) => suspend(() => predicate()
 /** @internal */
 const whenSTM = /*#__PURE__*/dual(2, (self, predicate) => flatMap(predicate, bool => bool ? asSome(self) : succeedNone));
 
-export { orElseFail as $, flatten as A, flip as B, flipWith as C, match as D, forEach as E, fromEither as F, fromOption as G, gen as H, head as I, if_ as J, ignore as K, isFailure as L, isSuccess as M, iterate as N, loop as O, mapAttempt as P, mapBoth as Q, mapError as R, merge as S, mergeAll as T, negate as U, none as V, option as W, orDie as X, orDieWith as Y, orElse as Z, orElseEither as _, acquireUseRelease as a, orElseOptional as a0, orElseSucceed as a1, partition as a2, provideContext as a3, provideSomeContext as a4, provideService as a5, provideServiceSTM as a6, reduce as a7, reduceAll as a8, reduceRight as a9, when as aA, whenSTM as aB, bind as aC, let_ as aD, bindTo as aE, refineOrDie as aa, refineOrDieWith as ab, reject as ac, rejectSTM as ad, repeatUntil as ae, repeatWhile as af, replicate as ag, replicateSTM as ah, replicateSTMDiscard as ai, retryUntil as aj, retryWhile as ak, some as al, succeedNone as am, succeedSome as an, summarized as ao, suspend as ap, tap as aq, tapBoth as ar, tapError as as, try_ as at, unless as au, unlessSTM as av, unsome as aw, unit as ax, validateAll as ay, validateFirst as az, all as b, as as c, asSome as d, asSomeError as e, asUnit as f, attempt as g, catchSome as h, catchTag as i, catchTags as j, check as k, collect as l, collectSTM as m, commitEither as n, cond as o, either as p, eventually as q, every as r, exists as s, fiberId as t, filter as u, filterNot as v, filterOrDie as w, filterOrDieMessage as x, filterOrElse as y, filterOrFail as z };
+export { acquireUseRelease, all, as, asSome, asSomeError, asUnit, attempt, bind, bindTo, catchSome, catchTag, catchTags, check, collect, collectSTM, commitEither, cond, either, eventually, every, exists, fiberId, filter, filterNot, filterOrDie, filterOrDieMessage, filterOrElse, filterOrFail, flatten, flip, flipWith, forEach, fromEither, fromOption, gen, head, if_, ignore, isFailure, isSuccess, iterate, let_, loop, mapAttempt, mapBoth, mapError, match, merge, mergeAll, negate, none, option, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseOptional, orElseSucceed, partition, provideContext, provideService, provideServiceSTM, provideSomeContext, reduce, reduceAll, reduceRight, refineOrDie, refineOrDieWith, reject, rejectSTM, repeatUntil, repeatWhile, replicate, replicateSTM, replicateSTMDiscard, retryUntil, retryWhile, some, succeedNone, succeedSome, summarized, suspend, tap, tapBoth, tapError, try_, unit, unless, unlessSTM, unsome, validateAll, validateFirst, when, whenSTM };

package/{dist/tArray-79024770.esm.js → internal/stm/tArray.esm.js}

@@ -1,10 +1,10 @@
-import { e as equals } from './Equal-2a99fde3.esm.js';
-import { d as dual, p as pipe } from './Function-12511160.esm.js';
-import { u as succeed, H as withSTMRuntime, r as map$1, C as effect, n as flatMap, g as dieMessage } from './core-f6cae6d7.esm.js';
-import { am as succeedNone, U as negate, N as iterate, E as forEach$1, an as succeedSome, a7 as reduce$1 } from './stm-6937f6f2.esm.js';
-import { u as unsafeGet, g as get$1, m as make$1, b as update$1, s as set, a as unsafeSet } from './tRef-fc8ff438.esm.js';
-import { m as map, a as isNone, i as isSome, b as match, s as some$1, n as none, e as fromNullable } from './Option-df40d2b9.esm.js';
-import { h as greaterThan, l as lessThan } from './Order-a875fe30.esm.js';
+import { equals } from '../../Equal/dist/effect-Equal.esm.js';
+import { dual, pipe } from '../../Function/dist/effect-Function.esm.js';
+import { succeed, withSTMRuntime, map as map$1, effect, flatMap, dieMessage } from './core.esm.js';
+import { succeedNone, negate, iterate, forEach as forEach$1, succeedSome, reduce as reduce$1 } from './stm.esm.js';
+import { unsafeGet, get as get$1, make as make$1, update as update$1, set, unsafeSet } from './tRef.esm.js';
+import { map, isNone, isSome, match, some as some$1, none, fromNullable } from '../../Option/dist/effect-Option.esm.js';
+import { greaterThan, lessThan } from '../../Order/dist/effect-Order.esm.js';
 
 /** @internal */
 const TArraySymbolKey = "effect/TArray";
@@ -284,4 +284,4 @@ const updateSTM = /*#__PURE__*/dual(3, (self, index, f) => {
   return pipe(get$1(self.chunk[index]), flatMap(f), flatMap(updated => set(self.chunk[index], updated)));
 });
 
-export { make as A, maxOption as B, minOption as C, reduce as D, reduceOption as E, reduceOptionSTM as F, reduceSTM as G, size as H, some as I, someSTM as J, toArray as K, transform as L, transformSTM as M, update as N, updateSTM as O, TArrayImpl as T, TArrayTypeId as a, collectFirstSTM as b, collectFirst as c, contains as d, count as e, fromIterable as f, countSTM as g, empty as h, every as i, everySTM as j, findFirst as k, findFirstIndex as l, findFirstIndexFrom as m, findFirstIndexWhere as n, findFirstIndexWhereFrom as o, findFirstIndexWhereSTM as p, findFirstIndexWhereFromSTM as q, findFirstSTM as r, findLast as s, findLastIndex as t, findLastIndexFrom as u, findLastSTM as v, forEach as w, get as x, headOption as y, lastOption as z };
+export { TArrayImpl, TArrayTypeId, collectFirst, collectFirstSTM, contains, count, countSTM, empty, every, everySTM, findFirst, findFirstIndex, findFirstIndexFrom, findFirstIndexWhere, findFirstIndexWhereFrom, findFirstIndexWhereFromSTM, findFirstIndexWhereSTM, findFirstSTM, findLast, findLastIndex, findLastIndexFrom, findLastSTM, forEach, fromIterable, get, headOption, lastOption, make, maxOption, minOption, reduce, reduceOption, reduceOptionSTM, reduceSTM, size, some, someSTM, toArray, transform, transformSTM, update, updateSTM };

package/internal/stm/tDeferred.esm.js

@@ -0,0 +1,49 @@
+import { left, right } from '../../Either/dist/effect-Either.esm.js';
+import { dual } from '../../Function/dist/effect-Function.esm.js';
+import { flatMap, zipRight, succeed as succeed$1, map } from './core.esm.js';
+import { flatten, collect, fromEither } from './stm.esm.js';
+import { get, set, make as make$1 } from './tRef.esm.js';
+import { isSome, some, none, match } from '../../Option/dist/effect-Option.esm.js';
+
+/** @internal */
+const TDeferredSymbolKey = "effect/TDeferred";
+
+/** @internal */
+const TDeferredTypeId = /*#__PURE__*/Symbol.for(TDeferredSymbolKey);
+
+/** @internal */
+const tDeferredVariance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class TDeferredImpl {
+  [TDeferredTypeId] = tDeferredVariance;
+  constructor(ref) {
+    this.ref = ref;
+  }
+}
+
+/** @internal */
+const _await = self => flatten(collect(get(self.ref), option => isSome(option) ? some(fromEither(option.value)) : none()));
+
+/** @internal */
+const done = /*#__PURE__*/dual(2, (self, either) => flatMap(get(self.ref), match({
+  onNone: () => zipRight(set(self.ref, some(either)), succeed$1(true)),
+  onSome: () => succeed$1(false)
+})));
+
+/** @internal */
+const fail = /*#__PURE__*/dual(2, (self, error) => done(self, left(error)));
+
+/** @internal */
+const make = () => map(make$1(none()), ref => new TDeferredImpl(ref));
+
+/** @internal */
+const poll = self => get(self.ref);
+
+/** @internal */
+const succeed = /*#__PURE__*/dual(2, (self, value) => done(self, right(value)));
+
+export { TDeferredTypeId, _await, done, fail, make, poll, succeed };