@typed/fx 0.0.16 → 0.0.18

package/src/Subject.ts

@@ -1,20 +1,30 @@
 import { Cause } from '@effect/core/io/Cause'
 import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-import { LazyArg } from '@tsplus/stdlib/data/Function'
+import * as Ref from '@effect/core/io/Ref'
+import { AtomicInternal, UnsafeAPI } from '@effect/core/io/Ref/operations/_internal/AtomicInternal'
+import { SynchronizedInternal } from '@effect/core/io/Ref/operations/_internal/SynchronizedInternal'
+import * as TSemaphore from '@effect/core/stm/TSemaphore'
+import { flow } from '@fp-ts/data/Function'
+import { LazyArg, pipe } from '@tsplus/stdlib/data/Function'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
-import { Fx } from './Fx.js'
+import { Emitter, Fx } from './Fx.js'
 import { never } from './fromEffect.js'
 import { Hold } from './hold.js'
 import { Multicast } from './multicast.js'
 
-export interface Subject<E, A> extends SubjectEmitter<E, A>, Fx<never, E, A> {}
+export interface Subject<E, A> extends Fx<never, E, A>, Emitter<never, E, A>, UnsafeEmitter<E, A> {}
 
-export interface SubjectEmitter<E, A> {
-  readonly emit: (a: A) => void
-  readonly failCause: (cause: Cause<E>) => void
-  readonly end: () => void
+export interface UnsafeEmitter<E, A> {
+  readonly unsafeEmit: (a: A) => void
+  readonly unsafeFailCause: (cause: Cause<E>) => void
+  readonly unsafeEnd: () => void
+}
+
+const FX_BRANDING = {
+  _R: () => void 0 as never,
+  _E: () => void 0 as any,
+  _A: () => void 0 as any,
 }
 
 export namespace Subject {
@@ -22,11 +32,15 @@ export namespace Subject {
     const m = new Multicast<never, E, A>(never)
 
     return {
+      ...FX_BRANDING,
       run: m.run.bind(m),
-      emit: (a) => Effect.unsafeRunAsync(m.emit(a)),
-      failCause: (c) => Effect.unsafeRunAsync(m.failCause(c)),
-      end: () => Effect.unsafeRunAsync(m.end),
-    } as Subject<E, A>
+      emit: m.emit.bind(m),
+      failCause: m.failCause.bind(m),
+      end: m.end,
+      unsafeEmit: (a) => Effect.unsafeRunAsync(m.emit(a)),
+      unsafeFailCause: (c) => Effect.unsafeRunAsync(m.failCause(c)),
+      unsafeEnd: () => Effect.unsafeRunAsync(m.end),
+    }
   }
 }
 
@@ -39,34 +53,150 @@ export namespace HoldSubject {
     const h = new Hold<never, E, A>(never)
 
     return {
-      run: h.run.bind(h),
-      get: h.get,
-      emit: (a) => Effect.unsafeRunAsync(h.emit(a)),
-      failCause: (c) => Effect.unsafeRunAsync(h.failCause(c)),
-      end: () => Effect.unsafeRunAsync(h.end),
-    } as HoldSubject<E, A>
+      ...FX_BRANDING,
+      get: Effect.sync(() => h.value.get),
+      run: (e) => h.run(e),
+      emit: (a) => h.emit(a),
+      failCause: (e) => h.failCause(e),
+      end: h.end,
+      unsafeEmit: (a) => Effect.unsafeRunAsync(h.emit(a)),
+      unsafeFailCause: (c) => Effect.unsafeRunAsync(h.failCause(c)),
+      unsafeEnd: () => Effect.unsafeRunAsync(h.end),
+    }
   }
 }
 
-export interface BehaviorSubject<E, A> extends Subject<E, A> {
-  readonly get: Effect.Effect<never, never, A>
-}
+export interface RefSubject<E, A> extends Subject<E, A>, Ref.Ref<A> {}
 
-export namespace BehaviorSubject {
-  export const unsafeMake = <E, A>(initial: LazyArg<A>): BehaviorSubject<E, A> => {
+export namespace RefSubject {
+  export const unsafeMake = <E, A>(initial: LazyArg<A>): RefSubject<E, A> => {
     const h = new Hold<never, E, A>(never)
+    const maybeRef: Ref.Ref<Maybe.Maybe<A>> = new AtomicInternal(new UnsafeAPI(h.value))
+    const ref = emitRefChanges(invmapRef(maybeRef, Maybe.getOrElse(initial), Maybe.some), h)
 
-    // We're mutating a protected variable here to ensure an initial value is held.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-expect-error
-    h._value = Maybe.some(initial())
+    // Ensure there is always a value in the Ref
+    h.value.set(Maybe.some(initial()))
 
     return {
+      ...FX_BRANDING,
+      [Ref.RefSym]: Ref.RefSym,
+      [Ref._A]: (_) => _,
+      get: ref.get,
+      modify: (f) => ref.modify(f),
+      set: (a) => ref.set(a),
+      getAndSet: (a) => ref.getAndSet(a),
+      getAndUpdate: (f) => ref.getAndUpdate(f),
+      getAndUpdateSome: (f) => ref.getAndUpdateSome(f),
+      modifySome: (fallback, f) => ref.modifySome(fallback, f),
+      update: (f) => ref.update(f),
+      updateAndGet: (f) => ref.updateAndGet(f),
+      updateSome: (f) => ref.updateSome(f),
+      updateSomeAndGet: (f) => ref.updateSomeAndGet(f),
       run: h.run.bind(h),
-      get: pipe(h.get, Effect.map(Maybe.getOrElse(initial))),
-      emit: (a) => Effect.unsafeRunAsync(h.emit(a)),
-      failCause: (c) => Effect.unsafeRunAsync(h.failCause(c)),
-      end: () => Effect.unsafeRunAsync(h.end),
-    } as BehaviorSubject<E, A>
+      emit: h.emit.bind(h),
+      failCause: h.failCause.bind(h),
+      end: h.end,
+      unsafeEmit: (a) => Effect.unsafeRunAsync(h.emit(a)),
+      unsafeFailCause: (c) => Effect.unsafeRunAsync(h.failCause(c)),
+      unsafeEnd: () => Effect.unsafeRunAsync(h.end),
+    }
+  }
+}
+
+export interface SynchronizedSubject<E, A> extends RefSubject<E, A>, Ref.Ref.Synchronized<A> {}
+
+export namespace SynchronizedSubject {
+  export const unsafeMake = <E, A>(initial: LazyArg<A>): SynchronizedSubject<E, A> => {
+    const subject = RefSubject.unsafeMake<E, A>(initial)
+    const synchronizedRef = new SynchronizedInternal(subject, TSemaphore.unsafeMake(1))
+
+    return {
+      ...subject,
+      [Ref.SynchronizedSym]: Ref.SynchronizedSym,
+      modifyEffect: (f) => synchronizedRef.modifyEffect(f),
+      modifySomeEffect: (fallback, f) => synchronizedRef.modifySomeEffect(fallback, f),
+      getAndUpdateEffect: (f) => synchronizedRef.getAndUpdateEffect(f),
+      getAndUpdateSomeEffect: (f) => synchronizedRef.getAndUpdateSomeEffect(f),
+      updateEffect: (f) => synchronizedRef.updateEffect(f),
+      updateAndGetEffect: (f) => synchronizedRef.updateAndGetEffect(f),
+      updateSomeEffect: (f) => synchronizedRef.updateSomeEffect(f),
+      updateSomeAndGetEffect: (f) => synchronizedRef.updateSomeAndGetEffect(f),
+    }
+  }
+}
+
+function invmapRef<A, B>(ref: Ref.Ref<A>, to: (a: A) => B, from: (b: B) => A): Ref.Ref<B> {
+  const get: Ref.Ref<B>['get'] = pipe(ref.get, Effect.map(to))
+
+  const modify: Ref.Ref<B>['modify'] = (f) =>
+    ref.modify((a) => {
+      const [b, c] = f(to(a))
+      return [b, from(c)]
+    })
+
+  const set: Ref.Ref<B>['set'] = flow(from, ref.set)
+
+  const getAndSet: Ref.Ref<B>['getAndSet'] = flow(from, ref.getAndSet, Effect.map(to))
+
+  const getAndUpdate: Ref.Ref<B>['getAndUpdate'] = (f) =>
+    pipe(ref.getAndUpdate(flow(to, f, from)), Effect.map(to))
+
+  const getAndUpdateSome: Ref.Ref<B>['getAndUpdateSome'] = (f) =>
+    pipe(ref.getAndUpdateSome(flow(to, f, Maybe.map(from))), Effect.map(to))
+
+  const modifySome: Ref.Ref<B>['modifySome'] = (fallback, f) =>
+    ref.modifySome(fallback, (a) =>
+      pipe(
+        a,
+        to,
+        f,
+        Maybe.map(([c, b]) => [c, from(b)]),
+      ),
+    )
+
+  const update: Ref.Ref<B>['update'] = (f) => ref.update(flow(to, f, from))
+
+  const updateAndGet: Ref.Ref<B>['updateAndGet'] = (f) =>
+    pipe(ref.updateAndGet(flow(to, f, from)), Effect.map(to))
+
+  const updateSome: Ref.Ref<B>['updateSome'] = (f) => ref.updateSome(flow(to, f, Maybe.map(from)))
+
+  const updateSomeAndGet: Ref.Ref<B>['updateSomeAndGet'] = (f) =>
+    pipe(ref.updateSomeAndGet(flow(to, f, Maybe.map(from))), Effect.map(to))
+
+  return {
+    [Ref.RefSym]: Ref.RefSym,
+    [Ref._A]: (_) => _,
+    get,
+    modify,
+    set,
+    getAndSet,
+    getAndUpdate,
+    getAndUpdateSome,
+    modifySome,
+    update,
+    updateAndGet,
+    updateSome,
+    updateSomeAndGet,
+  }
+}
+
+function emitRefChanges<A, E>(ref: Ref.Ref<A>, subject: Emitter<never, E, A>): Ref.Ref<A> {
+  const andEmitLatestValue = Effect.zipLeft(pipe(ref.get, Effect.flatMap(subject.emit)))
+
+  return {
+    [Ref.RefSym]: Ref.RefSym,
+    [Ref._A]: (_) => _,
+    get: ref.get,
+    modify: (f) => pipe(ref.modify(f), andEmitLatestValue),
+    set: (a) => pipe(ref.set(a), andEmitLatestValue),
+    getAndSet: (a) => pipe(ref.getAndSet(a), andEmitLatestValue),
+    getAndUpdate: (f) => pipe(ref.getAndUpdate(f), andEmitLatestValue),
+    getAndUpdateSome: (f) => pipe(ref.getAndUpdateSome(f), andEmitLatestValue),
+    modifySome: (fallback, f) => pipe(ref.modifySome(fallback, f), andEmitLatestValue),
+    update: (f) => pipe(ref.update(f), andEmitLatestValue),
+    updateAndGet: (f) => pipe(ref.updateAndGet(f), andEmitLatestValue),
+    updateSome: (f) => pipe(ref.updateSome(f), andEmitLatestValue),
+    updateSomeAndGet: (f) => pipe(ref.updateSomeAndGet(f), andEmitLatestValue),
   }
 }

package/src/hold.ts

@@ -4,6 +4,7 @@ import * as Fiber from '@effect/core/io/Fiber'
 import * as FiberId from '@effect/core/io/FiberId'
 import { Scope } from '@effect/core/io/Scope'
 import { pipe } from '@fp-ts/data/Function'
+import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
 import * as Duration from '@tsplus/stdlib/data/Duration'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
@@ -15,7 +16,7 @@ export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
 }
 
 export class Hold<R, E, A> extends Multicast<R, E, A> {
-  protected _value: Maybe.Maybe<A> = Maybe.none
+  readonly value: AtomicReference<Maybe.Maybe<A>> = new AtomicReference(Maybe.none)
   protected _pendingEmitters: Array<readonly [Emitter<unknown, E, A>, A[]]> = []
   protected _scheduledFiber: Fiber.RealFiber<any, any> | undefined
 
@@ -23,8 +24,6 @@ export class Hold<R, E, A> extends Multicast<R, E, A> {
     super(fx)
   }
 
-  readonly get = Effect.sync(() => this._value)
-
   run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown> {
     if (this.shouldScheduleFlush()) {
       return pipe(
@@ -66,14 +65,14 @@ export class Hold<R, E, A> extends Multicast<R, E, A> {
   }
 
   protected shouldScheduleFlush() {
-    return Maybe.isSome(this._value) && this.observers.length > 0
+    return Maybe.isSome(this.value.get) && this.observers.length > 0
   }
 
   protected scheduleFlush<R>(observer: Emitter<R, E, A>) {
     this._pendingEmitters.push([
       observer,
       pipe(
-        this._value,
+        this.value.get,
         Maybe.fold(
           () => [],
           (a) => [a],
@@ -121,7 +120,7 @@ export class Hold<R, E, A> extends Multicast<R, E, A> {
   }
 
   protected addValue(value: A) {
-    this._value = Maybe.some(value)
+    this.value.set(Maybe.some(value))
 
     this._pendingEmitters.forEach(([, values]) => {
       values.push(value)

package/src/withEmitter.test.ts

@@ -10,10 +10,10 @@ describe(import.meta.url, () => {
     it('should allow converting sync callbacks into an Fx', async () => {
       const test = pipe(
         Fx.withEmitter((emitter) => {
-          emitter.emit(1)
-          emitter.emit(2)
-          emitter.emit(3)
-          emitter.end()
+          emitter.unsafeEmit(1)
+          emitter.unsafeEmit(2)
+          emitter.unsafeEmit(3)
+          emitter.unsafeEnd()
 
           return Effect.unit
         }),

package/src/withEmitter.ts

@@ -5,10 +5,10 @@ import { Scope } from '@effect/core/io/Scope'
 import { flow, pipe } from '@fp-ts/data/Function'
 
 import { Emitter, Fx } from './Fx.js'
-import type { SubjectEmitter } from './Subject.js'
+import type { UnsafeEmitter } from './Subject.js'
 
 export function withEmitter<R, E, A>(
-  f: (emitter: SubjectEmitter<E, A>) => Effect.Canceler<R>,
+  f: (emitter: UnsafeEmitter<E, A>) => Effect.Canceler<R>,
 ): Fx<R, E, A> {
   return Fx<R, E, A>(<R2>(sink: Emitter<R2, E, A>) => {
     return Effect.withFiberRuntime<R | R2 | Scope, never, unknown>((fiber, status) => {
@@ -28,12 +28,12 @@ export function withEmitter<R, E, A>(
         Effect.zipRight(
           Effect.asyncEffect<R | R2, never, unknown, R | R2, never, any>((cb) => {
             canceler = f({
-              emit: (a) =>
+              unsafeEmit: (a) =>
                 unsafeRun(sink.emit(a), (exit) =>
                   Exit.isFailure(exit) ? cb(Effect.failCause(exit.cause)) : undefined,
                 ),
-              failCause: (e) => unsafeRun(sink.failCause(e), flow(Effect.done, cb)),
-              end: () => unsafeRun(sink.end, flow(Effect.done, cb)),
+              unsafeFailCause: (e) => unsafeRun(sink.failCause(e), flow(Effect.done, cb)),
+              unsafeEnd: () => unsafeRun(sink.end, flow(Effect.done, cb)),
             })
 
             return canceler