@effect-atom/atom 0.4.2 → 0.4.4

package/src/Atom.ts

@@ -140,6 +140,7 @@ export interface Context {
   self<A>(this: Context): Option.Option<A>
   setSelf<A>(this: Context, a: A): void
   set<R, W>(this: Context, atom: Writable<R, W>, value: W): void
+  setResult<A, E, W>(this: Context, atom: Writable<Result.Result<A, E>, W>, value: W): Effect.Effect<A, E>
   some<A>(this: Context, atom: Atom<Option.Option<A>>): Effect.Effect<A>
   someOnce<A>(this: Context, atom: Atom<Option.Option<A>>): Effect.Effect<A>
   stream<A>(this: Context, atom: Atom<A>, options?: {
@@ -167,6 +168,28 @@ export interface WriteContext<A> {
   set<R, W>(this: WriteContext<A>, atom: Writable<R, W>, value: W): void
 }
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setIdleTTL: {
+  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => A
+  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): A
+} = dual<
+  (duration: Duration.DurationInput) => <A extends Atom<any>>(self: A) => A,
+  <A extends Atom<any>>(self: A, duration: Duration.DurationInput) => A
+>(2, (self, durationInput) => {
+  const duration = Duration.decode(durationInput)
+  const isFinite = Duration.isFinite(duration)
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
+    ...self,
+    keepAlive: !isFinite,
+    idleTTL: isFinite ? Duration.toMillis(duration) : undefined
+  })
+})
+
+const removeTtl = setIdleTTL(0)
+
 const AtomProto = {
   [TypeId]: TypeId,
   pipe() {
@@ -217,7 +240,7 @@ const RuntimeProto = {
     readonly disableAccumulation?: boolean
     readonly initialValue?: ReadonlyArray<any>
   }) {
-    const pullSignal = state(0)
+    const pullSignal = removeTtl(state(0))
     const pullAtom = readable((get) => {
       const previous = get.self<Result.Result<any, any>>()
       const runtimeResult = get(this)
@@ -236,7 +259,7 @@ const RuntimeProto = {
 
   subscriptionRef(this: AtomRuntime<any, any>, ref: any) {
     return makeSubRef(
-      readable((get) => {
+      removeTtl(readable((get) => {
         const previous = get.self<Result.Result<any, any>>()
         const runtimeResult = get(this)
         if (runtimeResult._tag !== "Success") {
@@ -246,7 +269,7 @@ const RuntimeProto = {
         return SubscriptionRef.SubscriptionRefTypeId in value
           ? value
           : makeEffect(get, value, Result.initial(true), runtimeResult.value)
-      }),
+      })),
       (get, ref) => {
         const runtime = Result.getOrThrow(get(this))
         return readSubscribable(get, ref, runtime)
@@ -677,11 +700,11 @@ export const context: (options: {
   factory.addGlobalLayer = (layer: Layer.Layer<any, any, AtomRegistry | Reactivity.Reactivity>) => {
     globalLayer = Layer.provideMerge(globalLayer, Layer.provide(layer, Reactivity.layer))
   }
-  const reactivityAtom = make(
+  const reactivityAtom = removeTtl(make(
     Effect.scopeWith((scope) => Layer.buildWithMemoMap(Reactivity.layer, options.memoMap, scope)).pipe(
       Effect.map(EffectContext.get(Reactivity.Reactivity))
     )
-  )
+  ))
   factory.withReactivity =
     (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) =>
     <A extends Atom<any>>(atom: A): A =>
@@ -961,6 +984,7 @@ export interface FnContext {
   self<A>(this: FnContext): Option.Option<A>
   setSelf<A>(this: FnContext, a: A): void
   set<R, W>(this: FnContext, atom: Writable<R, W>, value: W): void
+  setResult<A, E, W>(this: Context, atom: Writable<Result.Result<A, E>, W>, value: W): Effect.Effect<A, E>
   some<A>(this: FnContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>
   stream<A>(this: FnContext, atom: Atom<A>, options?: {
     readonly withoutInitialValue?: boolean
@@ -1007,7 +1031,7 @@ export const fnSync: {
 const makeFnSync = <Arg, A>(f: (arg: Arg, get: FnContext) => A, options?: {
   readonly initialValue?: A
 }): Writable<Option.Option<A> | A, Arg> => {
-  const argAtom = state<[number, Arg]>([0, undefined as any])
+  const argAtom = removeTtl(state<[number, Arg]>([0, undefined as any]))
   const hasInitialValue = options?.initialValue !== undefined
   return writable(function(get) {
     ;(get as any).isFn = true
@@ -1100,16 +1124,16 @@ function makeResultFn<Arg, E, A>(
     readonly concurrent?: boolean | undefined
   }
 ) {
-  const argAtom = state<[number, Arg | Interrupt]>([0, undefined as any])
+  const argAtom = removeTtl(state<[number, Arg | Interrupt]>([0, undefined as any]))
   const initialValue = options?.initialValue !== undefined
     ? Result.success<A, E>(options.initialValue)
     : Result.initial<A, E>()
   const fibersAtom = options?.concurrent
-    ? make((get) => {
+    ? removeTtl(readable((get) => {
       const fibers = new Set<Fiber.RuntimeFiber<any, any>>()
       get.addFinalizer(() => fibers.forEach((f) => f.unsafeInterruptAsFork(FiberId.none)))
       return fibers
-    })
+    }))
     : undefined
 
   function read(get: Context, runtime?: Runtime.Runtime<any>): Result.Result<A, E | NoSuchElementException> {
@@ -1202,12 +1226,10 @@ export const pull = <A, E>(
     readonly disableAccumulation?: boolean | undefined
   }
 ): Writable<PullResult<A, E>, void> => {
-  const pullSignal = state(0)
-  const pullAtom = readable(
-    makeRead(function(get) {
-      return makeStreamPullEffect(get, pullSignal, create, options)
-    })
-  )
+  const pullSignal = removeTtl(state(0))
+  const pullAtom = readable(makeRead(function(get) {
+    return makeStreamPullEffect(get, pullSignal, create, options)
+  }))
   return makeStreamPull(pullSignal, pullAtom)
 }
 
@@ -1452,26 +1474,6 @@ export const withLabel: {
     label: [name, new Error().stack?.split("\n")[5] ?? ""]
   }))
 
-/**
- * @since 1.0.0
- * @category combinators
- */
-export const setIdleTTL: {
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => A
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): A
-} = dual<
-  (duration: Duration.DurationInput) => <A extends Atom<any>>(self: A) => A,
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput) => A
->(2, (self, durationInput) => {
-  const duration = Duration.decode(durationInput)
-  const isFinite = Duration.isFinite(duration)
-  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
-    ...self,
-    keepAlive: !isFinite,
-    idleTTL: isFinite ? Duration.toMillis(duration) : undefined
-  })
-})
-
 /**
  * @since 1.0.0
  * @category combinators
@@ -1593,12 +1595,12 @@ export const debounce: {
  */
 export const optimistic = <A>(self: Atom<A>): Writable<A, Atom<Result.Result<A, unknown>>> => {
   let counter = 0
-  const writeAtom = state(
+  const writeAtom = removeTtl(state(
     [
       counter,
       undefined as any as Atom<Result.Result<A, unknown>>
     ] as const
-  )
+  ))
   return writable(
     (get) => {
       let lastValue = get.once(self)
@@ -1714,7 +1716,7 @@ export const optimisticFn: {
       | ((set: (result: NoInfer<W>) => void) => AtomResultFn<OW, XA, XE>)
   }
 ): AtomResultFn<OW, XA, XE> => {
-  const transition = state<Result.Result<W, unknown>>(Result.initial())
+  const transition = removeTtl(state<Result.Result<W, unknown>>(Result.initial()))
   return fn((arg: OW, get) => {
     let value = options.reducer(get(self), arg)
     if (Result.isResult(value)) {

package/src/Result.ts

@@ -233,7 +233,7 @@ export const isInterrupted = <A, E>(result: Result<A, E>): result is Failure<A,
  * @since 1.0.0
  * @category constructors
  */
-export const failure = <E, A = never>(
+export const failure = <A, E = never>(
   cause: Cause.Cause<E>,
   options?: {
     readonly previousSuccess?: Option.Option<Success<A, E>> | undefined
@@ -417,6 +417,30 @@ export const map: {
   }
 })
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const flatMap: {
+  <A, E, B, E2>(f: (a: A, prev: Success<A, E>) => Result<A, E2>): (self: Result<A, E>) => Result<B, E | E2>
+  <E, A, B, E2>(self: Result<A, E>, f: (a: A, prev: Success<A, E>) => Result<B, E2>): Result<B, E | E2>
+} = dual(2, <E, A, B, E2>(self: Result<A, E>, f: (a: A, prev: Success<A, E>) => Result<B, E2>): Result<B, E | E2> => {
+  switch (self._tag) {
+    case "Initial":
+      return self as any as Result<B, E>
+    case "Failure":
+      return failure<B, E | E2>(self.cause, {
+        previousSuccess: Option.flatMap(self.previousSuccess, (s) => {
+          const next = f(s.value, s)
+          return isSuccess(next) ? Option.some(next) : Option.none()
+        }),
+        waiting: self.waiting
+      })
+    case "Success":
+      return f(self.value, self)
+  }
+})
+
 /**
  * @since 1.0.0
  * @category combinators

package/src/internal/registry.ts

@@ -578,6 +578,14 @@ const LifetimeProto: Omit<Lifetime<any>, "node" | "finalizers" | "disposed" | "i
     })
   },
 
+  setResult<A, E, W>(this: Lifetime<any>, atom: Atom.Writable<Result.Result<A, E>, W>, value: W): Effect.Effect<A, E> {
+    if (this.disposed) {
+      throw disposedError(this.node.atom)
+    }
+    this.node.registry.set(atom, value)
+    return this.resultOnce(atom, { suspendOnWaiting: true })
+  },
+
   some<A>(this: Lifetime<any>, atom: Atom.Atom<Option.Option<A>>): Effect.Effect<A> {
     if (this.disposed) {
       throw disposedError(this.node.atom)