@typed/fx 1.6.2 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/fx",
-  "version": "1.6.2",
+  "version": "1.8.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -19,12 +19,15 @@
     }
   },
   "dependencies": {
-    "@effect/data": "^0.10.3",
-    "@effect/io": "^0.17.0"
+    "@effect/data": "^0.11.7",
+    "@effect/io": "^0.19.2"
   },
-  "gitHead": "f1b68c605b7b6f2dd8dbc254697592abc15f639e",
+  "gitHead": "7baa08a653259f97ebd4b0d7b8ce4f1bbe2a5997",
   "publishConfig": {
     "access": "public"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "devDependencies": {
+    "vitest": "^0.30.0"
+  }
 }

package/src/Fx.ts

@@ -0,0 +1,109 @@
+import type { Trace } from '@effect/data/Debug'
+import { methodWithTrace } from '@effect/data/Debug'
+import { identity } from '@effect/data/Function'
+import type { Cause } from '@effect/io/Cause'
+import type { Effect } from '@effect/io/Effect'
+import type * as Runtime from '@effect/io/Runtime'
+
+export const FxTypeId = Symbol.for('@typed/fx/Fx')
+export type FxTypeId = typeof FxTypeId
+
+export interface Fx<out R, out E, out A> {
+  readonly [FxTypeId]: {
+    readonly _R: (_: never) => R
+    readonly _E: (_: never) => E
+    readonly _A: (_: never) => A
+  }
+
+  readonly run: <R2>(sink: Sink<R2, E, A>) => Effect<R | R2, never, void>
+
+  readonly traced: (trace: Trace) => Fx<R, E, A>
+}
+
+export const make: <R, E, A>(
+  run: <R2>(sink: Sink<R2, E, A>) => Effect<R | R2, never, void>,
+) => Fx<R, E, A> = methodWithTrace(
+  (trace) =>
+    function Fx<R, E, A>(run: Fx<R, E, A>['run']): Fx<R, E, A> {
+      const fx: Fx<R, E, A> = {
+        [FxTypeId]: {
+          _R: identity,
+          _E: identity,
+          _A: identity,
+        },
+        run: methodWithTrace((inner) => (sink) => run(sink).traced(inner).traced(trace)),
+        traced: (inner) => Traced(Traced(fx, inner), trace),
+      }
+
+      return fx
+    },
+)
+
+export function Fx<R, E, A>(
+  run: <R2>(sink: Sink<R2, E, A>) => Effect<R | R2, never, void>,
+): Fx<R, E, A> {
+  return make(run)
+}
+
+export function Traced<R, E, A>(fx: Fx<R, E, A>, trace: Trace): Fx<R, E, A> {
+  const traced: Fx<R, E, A> = {
+    [FxTypeId]: {
+      _R: identity,
+      _E: identity,
+      _A: identity,
+    },
+    run: (sink) =>
+      fx
+        .run(
+          Sink(
+            (a: A) => sink.event(a).traced(trace),
+            (cause: Cause<E>) => sink.error(cause).traced(trace),
+          ),
+        )
+        .traced(trace),
+    traced: (trace) => Traced(traced, trace),
+  }
+
+  return traced
+}
+
+export namespace Fx {
+  export type Cancel = Runtime.Cancel<never, void>
+
+  export type ResourcesOf<T> = [T] extends [never]
+    ? never
+    : T extends Fx<infer R, any, any>
+    ? R
+    : never
+
+  export type ErrorsOf<T> = [T] extends [never]
+    ? never
+    : T extends Fx<any, infer E, any>
+    ? E
+    : never
+
+  export type OutputOf<T> = [T] extends [never]
+    ? never
+    : T extends Fx<any, any, infer A>
+    ? A
+    : never
+}
+
+export interface Sink<R, E, A> {
+  readonly event: (a: A) => Effect<R, never, void>
+  readonly error: (e: Cause<E>) => Effect<R, never, void>
+}
+
+export function Sink<A, R, E, R2>(
+  event: (a: A) => Effect<R, never, void>,
+  error: (e: Cause<E>) => Effect<R2, never, void>,
+): Sink<R | R2, E, A> {
+  return {
+    event: methodWithTrace((trace) => (a: A) => event(a).traced(trace)),
+    error: methodWithTrace((trace) => (e: Cause<E>) => error(e).traced(trace)),
+  }
+}
+
+export function isFx<R, E, A>(v: unknown): v is Fx<R, E, A> {
+  return typeof v === 'object' && v != null && FxTypeId in v
+}

package/src/RefSubject.test.ts

@@ -0,0 +1,352 @@
+import { deepStrictEqual } from 'assert'
+
+import { describe, it } from 'vitest'
+
+import { makeRef, RefSubject } from './RefSubject.js'
+import { Chunk, Duration, Effect, Fiber, Option } from './externals.js'
+import { toChunk } from './toChunk.js'
+
+describe('RefSubject', () => {
+  describe('get', () => {
+    it('lazily instantiates the value', async () => {
+      const test = Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(Effect.succeed(1)))
+        const value = yield* $(ref.get)
+
+        deepStrictEqual(value, 1)
+      })
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('modifyEffect', () => {
+    it('allows modifying the value with an Effect', async () => {
+      const test = Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(Effect.succeed(1)))
+
+        deepStrictEqual(yield* $(ref.modifyEffect((a) => Effect.succeed([null, a + 1]))), null)
+        deepStrictEqual(yield* $(ref.get), 2)
+      })
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('modify', () => {
+    it('allows modifying the value', async () => {
+      const test = Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(Effect.succeed(1)))
+
+        deepStrictEqual(yield* $(ref.modify((a) => [null, a + 1])), null)
+        deepStrictEqual(yield* $(ref.get), 2)
+      })
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('set', () => {
+    it('allows setting the value', async () => {
+      const test = Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(Effect.succeed(1)))
+
+        yield* $(ref.set(2))
+        deepStrictEqual(yield* $(ref.get), 2)
+      })
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('delete', () => {
+    it('allows deleting the value', async () => {
+      const test = Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(Effect.succeed(1)))
+
+        // If the value has not be initialized, it will be return None
+        deepStrictEqual(yield* $(ref.delete), Option.none())
+
+        // Initialize the value
+        deepStrictEqual(yield* $(ref.get), 1)
+
+        // Delete the value, returning the previously set value
+        deepStrictEqual(yield* $(ref.delete), Option.some(1))
+      })
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('map', () => {
+    it('computes the value from another ref', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const ref = yield* $(makeRef(Effect.succeed(1)))
+          const computed = ref.map((a) => a + 1)
+
+          deepStrictEqual(yield* $(computed.get), 2)
+          deepStrictEqual(yield* $(ref.set(2)), 2)
+          deepStrictEqual(yield* $(computed.get), 3)
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('Computed', () => {
+    describe('map', () => {
+      it('computes the value from another Computed', async () => {
+        const test = Effect.scoped(
+          Effect.gen(function* ($) {
+            const ref = yield* $(makeRef(Effect.succeed(1)))
+            const addOne = ref.map((a) => a + 1)
+            const multiplyTwo = addOne.map((a) => a * 2)
+
+            // Initial
+            deepStrictEqual(yield* $(addOne.get), 2)
+            deepStrictEqual(yield* $(multiplyTwo.get), 4)
+
+            // Update ref value
+            deepStrictEqual(yield* $(ref.set(2)), 2)
+            deepStrictEqual(yield* $(addOne.get), 3)
+            deepStrictEqual(yield* $(multiplyTwo.get), 6)
+          }),
+        )
+
+        await Effect.runPromise(test)
+      })
+
+      it('can be observed', async () => {
+        const test = Effect.scoped(
+          Effect.gen(function* ($) {
+            const ref = yield* $(makeRef(Effect.succeed(1)))
+            const addOne = ref.map((a) => a + 1)
+            const multiplyTwo = addOne.map((a) => a * 2)
+            const fiber = yield* $(Effect.fork(toChunk(multiplyTwo)))
+
+            // Allow fiber and inner streams to begin
+            yield* $(Effect.sleep(Duration.millis(0)))
+
+            // Update ref value
+            deepStrictEqual(yield* $(ref.set(2)), 2)
+            deepStrictEqual(yield* $(ref.set(3)), 3)
+            yield* $(ref.end())
+
+            const results = yield* $(Fiber.join(fiber))
+
+            deepStrictEqual(Chunk.toReadonlyArray(results), [4, 6, 8])
+          }),
+        )
+
+        await Effect.runPromise(test)
+      })
+    })
+  })
+
+  describe('Fx', () => {
+    it('can be observed', async () => {
+      const test = Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(Effect.succeed(1)))
+        const fiber = yield* $(Effect.fork(toChunk(ref)))
+
+        yield* $(Effect.sleep(Duration.millis(0)))
+
+        yield* $(ref.set(2))
+        yield* $(ref.set(3))
+        yield* $(ref.end())
+
+        const results = yield* $(Fiber.join(fiber))
+
+        deepStrictEqual(Chunk.toReadonlyArray(results), [1, 2, 3])
+      })
+
+      await Effect.runPromise(Effect.scoped(test))
+    })
+  })
+
+  describe('tuple', () => {
+    it('bidirectionally maps a tuple of refs', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const a = yield* $(makeRef(Effect.succeed(1)))
+          const b = yield* $(makeRef(Effect.succeed(2)))
+          const c = yield* $(makeRef(Effect.succeed(3)))
+          const ref = RefSubject.tuple(a, b, c)
+
+          deepStrictEqual(yield* $(ref.get), [1, 2, 3])
+
+          yield* $(ref.set([2, 3, 4]))
+
+          deepStrictEqual(yield* $(a.get), 2)
+          deepStrictEqual(yield* $(b.get), 3)
+          deepStrictEqual(yield* $(c.get), 4)
+
+          deepStrictEqual(yield* $(ref.get), [2, 3, 4])
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+
+    it('can be observed', async () => {
+      const test = Effect.gen(function* ($) {
+        const a = yield* $(makeRef(Effect.succeed(1)))
+        const b = yield* $(makeRef(Effect.succeed(2)))
+        const c = yield* $(makeRef(Effect.succeed(3)))
+        const ref = RefSubject.tuple(a, b, c)
+        const fiber = yield* $(Effect.fork(toChunk(ref)))
+
+        // Allow fiber and inner streams to begin
+        yield* $(Effect.sleep(Duration.millis(0)))
+
+        yield* $(a.set(2))
+        yield* $(b.set(3))
+        yield* $(c.set(4))
+        yield* $(ref.end())
+
+        const results = yield* $(Fiber.join(fiber))
+
+        deepStrictEqual(Chunk.toReadonlyArray(results), [
+          [1, 2, 3],
+          [2, 2, 3],
+          [2, 3, 3],
+          [2, 3, 4],
+        ])
+      })
+
+      await Effect.runPromise(Effect.scoped(test))
+    })
+
+    it('can be computed', async () => {
+      const test = Effect.gen(function* ($) {
+        const a = yield* $(makeRef(Effect.succeed(1)))
+        const b = yield* $(makeRef(Effect.succeed(2)))
+        const c = yield* $(makeRef(Effect.succeed(3)))
+        const ref = RefSubject.tuple(a, b, c)
+        const computed = ref.map(([a, b, c]) => [a + 1, b + 1, c + 1])
+        const fiber = yield* $(Effect.fork(toChunk(computed)))
+
+        // Allow fiber and inner streams to begin
+        yield* $(Effect.sleep(Duration.millis(0)))
+
+        yield* $(a.set(2))
+        yield* $(b.set(3))
+        yield* $(c.set(4))
+        yield* $(ref.end())
+
+        const results = yield* $(Fiber.join(fiber))
+
+        deepStrictEqual(Chunk.toReadonlyArray(results), [
+          [2, 3, 4],
+          [3, 3, 4],
+          [3, 4, 4],
+          [3, 4, 5],
+        ])
+      })
+
+      await Effect.runPromise(Effect.scoped(test))
+    })
+  })
+
+  describe('struct', () => {
+    it('bidirectionally maps a struct of refs', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const a = yield* $(makeRef(Effect.succeed(1)))
+          const b = yield* $(makeRef(Effect.succeed(2)))
+          const c = yield* $(makeRef(Effect.succeed(3)))
+          const ref = RefSubject.struct({ a, b, c })
+
+          deepStrictEqual(yield* $(ref.get), { a: 1, b: 2, c: 3 })
+
+          yield* $(ref.set({ a: 2, b: 3, c: 4 }))
+
+          deepStrictEqual(yield* $(a.get), 2)
+          deepStrictEqual(yield* $(b.get), 3)
+          deepStrictEqual(yield* $(c.get), 4)
+
+          deepStrictEqual(yield* $(ref.get), { a: 2, b: 3, c: 4 })
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+
+    it('can be observed', async () => {
+      const test = Effect.gen(function* ($) {
+        const a = yield* $(makeRef(Effect.succeed(1)))
+        const b = yield* $(makeRef(Effect.succeed(2)))
+        const c = yield* $(makeRef(Effect.succeed(3)))
+        const ref = RefSubject.struct({ a, b, c })
+        const fiber = yield* $(Effect.fork(toChunk(ref)))
+
+        // Allow fiber and inner streams to begin
+        yield* $(Effect.sleep(Duration.millis(0)))
+
+        yield* $(a.set(2))
+        yield* $(b.set(3))
+        yield* $(c.set(4))
+        yield* $(ref.end())
+
+        const results = yield* $(Fiber.join(fiber))
+
+        deepStrictEqual(Chunk.toReadonlyArray(results), [
+          { a: 1, b: 2, c: 3 },
+          { a: 2, b: 2, c: 3 },
+          {
+            a: 2,
+            b: 3,
+            c: 3,
+          },
+          { a: 2, b: 3, c: 4 },
+        ])
+      })
+
+      await Effect.runPromise(Effect.scoped(test))
+    })
+  })
+
+  describe('all', () => {
+    it('bidirectionally maps a tuple of refs', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const a = yield* $(makeRef(Effect.succeed(1)))
+          const b = yield* $(makeRef(Effect.succeed(2)))
+          const c = yield* $(makeRef(Effect.succeed(3)))
+          const ref = RefSubject.all([a, b, c])
+
+          deepStrictEqual(yield* $(ref.get), [1, 2, 3])
+
+          yield* $(ref.set([2, 3, 4]))
+
+          deepStrictEqual(yield* $(a.get), 2)
+          deepStrictEqual(yield* $(b.get), 3)
+          deepStrictEqual(yield* $(c.get), 4)
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+
+    it('bidirectionally maps a struct of refs', async () => {
+      const test = Effect.gen(function* ($) {
+        const a = yield* $(makeRef(Effect.succeed(1)))
+        const b = yield* $(makeRef(Effect.succeed(2)))
+        const c = yield* $(makeRef(Effect.succeed(3)))
+        const ref = RefSubject.all({ a, b, c })
+
+        deepStrictEqual(yield* $(ref.get), { a: 1, b: 2, c: 3 })
+
+        yield* $(ref.set({ a: 2, b: 3, c: 4 }))
+
+        deepStrictEqual(yield* $(a.get), 2)
+        deepStrictEqual(yield* $(b.get), 3)
+        deepStrictEqual(yield* $(c.get), 4)
+      })
+
+      await Effect.runPromise(test)
+    })
+  })
+})