@typed/fx 1.17.3 → 1.18.0

package/src/RefSubject.test.ts

@@ -1,437 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Chunk from '@effect/data/Chunk'
-import * as Duration from '@effect/data/Duration'
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import { describe, it } from 'vitest'
-
-import { Computed } from './Computed.js'
-import { makeRef, RefSubject } from './RefSubject.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)
-
-        deepStrictEqual(value, 1)
-      })
-
-      await Effect.runPromise(Effect.scoped(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(Effect.scoped(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(Effect.scoped(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(Effect.scoped(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(Effect.scoped(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), 2)
-          deepStrictEqual(yield* $(ref.set(2)), 2)
-          deepStrictEqual(yield* $(computed), 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)
-      })
-
-      it('does not recompute value when underlying ref has not changed', async () => {
-        const test = Effect.scoped(
-          Effect.gen(function* ($) {
-            let calls = 0
-            const ref = yield* $(makeRef(Effect.succeed(1)))
-            const addOne = ref.map((x) => {
-              calls++
-              return x + 1
-            })
-
-            deepStrictEqual(yield* $(addOne), 2)
-            deepStrictEqual(yield* $(addOne), 2)
-            deepStrictEqual(yield* $(addOne), 2)
-            deepStrictEqual(calls, 1)
-
-            yield* $(ref.update((x) => x + 1))
-
-            deepStrictEqual(yield* $(addOne), 3)
-            deepStrictEqual(yield* $(addOne), 3)
-            deepStrictEqual(yield* $(addOne), 3)
-            deepStrictEqual(calls, 2)
-          }),
-        )
-
-        await Effect.runPromise(test)
-      })
-
-      it('does not recompute value when underlying ref has not changed with multiple layers', async () => {
-        const test = Effect.scoped(
-          Effect.gen(function* ($) {
-            let addOneCalls = 0
-            let multiplyTwoCalls = 0
-            const ref = yield* $(makeRef(Effect.succeed(1)))
-            const addOne = ref.map((x) => {
-              addOneCalls++
-              return x + 1
-            })
-            const multiplyTwo = addOne.map((a) => {
-              multiplyTwoCalls++
-              return a * 2
-            })
-
-            deepStrictEqual(yield* $(multiplyTwo), 4)
-            deepStrictEqual(yield* $(multiplyTwo), 4)
-            deepStrictEqual(yield* $(multiplyTwo), 4)
-            deepStrictEqual(addOneCalls, 1)
-            deepStrictEqual(multiplyTwoCalls, 1)
-
-            yield* $(ref.update((x) => x + 1))
-
-            deepStrictEqual(yield* $(multiplyTwo), 6)
-            deepStrictEqual(yield* $(multiplyTwo), 6)
-            deepStrictEqual(yield* $(multiplyTwo), 6)
-            deepStrictEqual(addOneCalls, 2)
-            deepStrictEqual(multiplyTwoCalls, 2)
-          }),
-        )
-
-        await Effect.runPromise(test)
-      })
-
-      it('allows being combined with other 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)
-            const combined = Computed.tuple(addOne, multiplyTwo)
-
-            deepStrictEqual(yield* $(combined.get), [2, 4])
-
-            yield* $(ref.set(2))
-
-            deepStrictEqual(yield* $(combined.get), [3, 6])
-          }),
-        )
-
-        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(Effect.scoped(test))
-    })
-  })
-})

package/src/RefTransform.ts

@@ -1,210 +0,0 @@
-import * as Equal from '@effect/data/Equal'
-import { pipe, identity } from '@effect/data/Function'
-import * as Hash from '@effect/data/Hash'
-import * as MutableRef from '@effect/data/MutableRef'
-import * as Option from '@effect/data/Option'
-import { Pipeable, pipeArguments } from '@effect/data/Pipeable'
-import * as Effect from '@effect/io/Effect'
-import * as Channel from '@effect/stream/Channel'
-import * as Sink from '@effect/stream/Sink'
-import * as Stream from '@effect/stream/Stream'
-
-import * as Fx from './Fx.js'
-import { combineAll } from './combineAll.js'
-
-const fxVariance = {
-  _R: identity,
-  _E: identity,
-  _A: identity,
-}
-
-export interface RefTransformInput<R, E, A, R2, E2, B> extends Fx.Fx<R, E, A> {
-  readonly get: Effect.Effect<R2, E2, B>
-
-  /** @internal */
-  readonly version: () => number
-}
-
-export namespace RefTransformInput {
-  export type Any = RefTransform<any, any, any, any, any, any>
-  export type TupleAny = ReadonlyArray<Any>
-
-  export type FxContext<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<infer R, any, any, any, any, any>
-    ? R
-    : never
-
-  export type FxError<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<any, infer E, any, any, any, any>
-    ? E
-    : never
-
-  export type FxSuccess<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<any, any, infer A, any, any, any>
-    ? A
-    : never
-
-  export type Fx<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<infer R, infer E, infer A, any, any, any>
-    ? Fx.Fx<R, E, A>
-    : never
-
-  export type GetContext<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<any, any, any, infer R, any, any>
-    ? R
-    : never
-
-  export type GetError<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<any, any, any, any, infer E, any>
-    ? E
-    : never
-
-  export type GetSuccess<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<any, any, any, any, any, infer A>
-    ? A
-    : never
-
-  export type Get<T> = [T] extends [never]
-    ? never
-    : T extends RefTransformInput<any, any, any, infer R, infer E, infer A>
-    ? Effect.Effect<R, E, A>
-    : never
-
-  export function tuple<const Inputs extends TupleAny>(
-    inputs: Inputs,
-  ): RefTransformInput<
-    FxContext<Inputs[number]>,
-    FxError<Inputs[number]>,
-    { readonly [K in keyof Inputs]: FxSuccess<Inputs[K]> },
-    GetContext<Inputs[number]>,
-    GetError<Inputs[number]>,
-    { readonly [K in keyof Inputs]: GetSuccess<Inputs[K]> }
-  > {
-    return Object.assign(combineAll(...inputs), {
-      get: Effect.all(inputs.map((input) => input.get)),
-      version: () => inputs.reduce((acc, input) => Math.max(acc, input.version()), 0),
-    }) as any
-  }
-}
-
-export interface RefTransform<R, E, A, R2, E2, B>
-  extends Fx.Fx<R, E, A>,
-    Effect.Effect<R2, E2, B>,
-    Pipeable {
-  readonly get: Effect.Effect<R2, E2, B>
-
-  transform<R3, E3, C>(
-    f: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>,
-  ): RefTransform<R3, E3, C, R2, E2, B>
-
-  transformGet<R3, E3, C>(
-    f: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R3, E3, C>,
-  ): RefTransform<R, E, A, R3, E3, C>
-
-  transformBoth<R3, E3, C, R4, E4, D>(
-    f: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>,
-    g: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>,
-  ): RefTransform<R3, E3, C, R4, E4, D>
-
-  /** @internal */
-  readonly version: () => number
-}
-
-export class RefTransformImpl<R0, E0, A0, R1, E1, A1, R2, E2, B, R3, E3, C>
-  implements RefTransform<R2, E2, B, R3, E3, C>
-{
-  readonly _tag = 'Commit';
-  readonly [Effect.EffectTypeId] = fxVariance;
-  readonly [Sink.SinkTypeId] = fxVariance as any;
-  readonly [Channel.ChannelTypeId] = fxVariance as any;
-  readonly [Stream.StreamTypeId] = fxVariance as any;
-
-  readonly [Fx.FxTypeId] = fxVariance
-
-  readonly fx: Fx.Fx<R2, E2, B>
-  readonly get: Effect.Effect<R3, E3, C>
-
-  protected _lastVersion: number
-  protected _currentValue: MutableRef.MutableRef<Option.Option<C>> = MutableRef.make(Option.none())
-
-  constructor(
-    readonly i0: RefTransformInput<R0, E0, A0, R1, E1, A1>,
-    readonly i1: (fx: Fx.Fx<R0, E0, A0>) => Fx.Fx<R2, E2, B>,
-    readonly i2: (effect: Effect.Effect<R1, E1, A1>) => Effect.Effect<R3, E3, C>,
-  ) {
-    this.fx = i1(i0)
-
-    this._lastVersion = i0.version()
-
-    this.get = Effect.suspend(() => {
-      const currentVersion = i0.version()
-      const currentValue = MutableRef.get(this._currentValue)
-
-      // Avoid computing a new value when the underlying ref hasn't changed
-      if (currentVersion === this._lastVersion && Option.isSome(currentValue)) {
-        return Effect.succeed(currentValue.value)
-      }
-
-      return Effect.flatMap(i2(i0.get), (value) =>
-        Effect.sync(() => {
-          this._lastVersion = i0.version()
-
-          MutableRef.set(this._currentValue, Option.some(value))
-
-          return value
-        }),
-      )
-    })
-  }
-
-  run<R4>(sink: Fx.Sink<R4, E2, B>) {
-    return this.fx.run(sink)
-  }
-
-  transform<R4, E4, D>(f: (fx: Fx.Fx<R2, E2, B>) => Fx.Fx<R4, E4, D>) {
-    return new RefTransformImpl(this.i0, (a) => pipe(a, this.i1, f), this.i2)
-  }
-
-  transformGet<R4, E4, D>(f: (effect: Effect.Effect<R3, E3, C>) => Effect.Effect<R4, E4, D>) {
-    return new RefTransformImpl(this.i0, this.i1, (a) => pipe(a, this.i2, f))
-  }
-
-  transformBoth<R4, E4, D, R5, E5, E>(
-    f: (fx: Fx.Fx<R2, E2, B>) => Fx.Fx<R4, E4, D>,
-    g: (effect: Effect.Effect<R3, E3, C>) => Effect.Effect<R5, E5, E>,
-  ): RefTransformImpl<R0, E0, A0, R1, E1, A1, R4, E4, D, R5, E5, E> {
-    return new RefTransformImpl(
-      this.i0,
-      (a) => pipe(a, this.i1, f),
-      (a) => pipe(a, this.i2, g),
-    )
-  }
-
-  pipe() {
-    // eslint-disable-next-line prefer-rest-params
-    return pipeArguments(this, arguments)
-  }
-
-  version() {
-    return this.i0.version()
-  }
-
-  [Equal.symbol](that: unknown) {
-    return this === that
-  }
-
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
-
-  commit() {
-    return this.get
-  }
-}

package/src/at.ts

@@ -1,8 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from './Fx.js'
-
-export function at<A>(value: A, delay: Duration.Duration): Fx<never, never, A> {
-  return Fx((sink) => Effect.delay(sink.event(value), delay))
-}

package/src/catchAllCause.test.ts

@@ -1,23 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { catchAll, catchAllCause } from './catchAllCause.js'
-import { delay } from './delay.js'
-import { fail } from './failCause.js'
-import { fromArray } from './fromArray.js'
-import { mergeAll } from './mergeAll.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(catchAllCause.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'merges multiple streams together when they error, infinite concurrency',
-      catchAll(mergeAll(...array.map((n) => fail(n))), (x) =>
-        delay(fromArray([x]), Duration.millis(10)),
-      ),
-      array,
-    )
-  })
-})