@typed/fx 1.13.0 → 1.14.0

package/src/Filtered.ts

@@ -0,0 +1,112 @@
+import { pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+
+import { RefTransform, RefTransformImpl, RefTransformInput } from './RefTransform.js'
+import { compact } from './filterMap.js'
+import { switchMapEffect } from './switchMap.js'
+
+export const FilteredTypeId = Symbol.for('@typed/fx/Filtered')
+export type FilteredTypeId = typeof FilteredTypeId
+
+export interface Filtered<R, E, A>
+  extends RefTransform<R, E, A, R, E | Cause.NoSuchElementException, A> {
+  readonly [FilteredTypeId]: FilteredTypeId
+
+  filterMapEffect<R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
+  ): Filtered<R | R2, E | E2, B>
+
+  filterMap<R2, E2, B>(f: (a: A) => Option.Option<B>): Filtered<R | R2, E | E2, B>
+
+  filter<R2, E2>(f: (a: A) => boolean): Filtered<R | R2, E | E2, A>
+
+  filterEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): Filtered<R | R2, E | E2, A>
+
+  filterNot<R2, E2>(f: (a: A) => boolean): Filtered<R | R2, E | E2, A>
+
+  filterNotEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): Filtered<R | R2, E | E2, A>
+
+  mapEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): Filtered<R | R2, E | E2, B>
+
+  map<B>(f: (a: A) => B): Filtered<R, E, B>
+
+  /**
+   * @internal
+   */
+  version(): number
+}
+
+export class FilteredImpl<R, E, A, R2, E2, R3, E3, C>
+  extends RefTransformImpl<
+    R,
+    E,
+    A,
+    R2,
+    E2,
+    A,
+    R | R2 | R3,
+    E | E2 | E3,
+    C,
+    R | R2 | R3,
+    E | E2 | E3 | Cause.NoSuchElementException,
+    C
+  >
+  implements Filtered<R | R2 | R3, E | E2 | E3, C>
+{
+  readonly [FilteredTypeId]: FilteredTypeId = FilteredTypeId
+
+  constructor(
+    input: RefTransformInput<R, E, A, R2, E2, A>,
+    f: (a: A) => Effect.Effect<R3, E3, Option.Option<C>>,
+  ) {
+    super(
+      input,
+      (fx) => compact(switchMapEffect(fx, f)),
+      (eff) => Effect.flatten(Effect.flatMap(eff, f)),
+    )
+  }
+
+  filterMapEffect<R4, E4, D>(
+    f: (a: C) => Effect.Effect<R4, E4, Option.Option<D>>,
+  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, D> {
+    return new FilteredImpl(this, f) as Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, D>
+  }
+
+  filterMap<D>(f: (a: C) => Option.Option<D>) {
+    return this.filterMapEffect((a) => Effect.sync(() => f(a)))
+  }
+
+  filterEffect<R4, E4>(
+    f: (a: C) => Effect.Effect<R4, E4, boolean>,
+  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, C> {
+    return this.filterMapEffect((a) =>
+      Effect.map(f(a), (b) => (b ? Option.some<C>(a) : Option.none<C>())),
+    )
+  }
+
+  filter(f: (a: C) => boolean) {
+    return this.filterEffect((a) => Effect.sync(() => f(a)))
+  }
+
+  filterNotEffect<R4, E4>(
+    f: (a: C) => Effect.Effect<R4, E4, boolean>,
+  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, C> {
+    return this.filterEffect((a) => Effect.map(f(a), (b) => !b))
+  }
+
+  filterNot(f: (a: C) => boolean) {
+    return this.filterNotEffect((a) => Effect.sync(() => f(a)))
+  }
+
+  mapEffect<R4, E4, D>(
+    f: (a: C) => Effect.Effect<R4, E4, D>,
+  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, D> {
+    return this.filterMapEffect((a) => pipe(a, f, Effect.map(Option.some)))
+  }
+
+  map<D>(f: (a: C) => D) {
+    return this.mapEffect((a) => Effect.sync(() => f(a)))
+  }
+}

package/src/Fx.ts

@@ -1,5 +1,3 @@
-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'
@@ -16,28 +14,24 @@ export interface Fx<out R, out E, out A> {
   }
 
   readonly run: <R2>(sink: Sink<R2, E, A>) => Effect<R | R2, never, void>
+}
 
-  readonly addTrace: (trace: Trace) => Fx<R, E, A>
+const fxVariance = {
+  _R: identity,
+  _E: identity,
+  _A: identity,
 }
 
 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)),
-        addTrace: (inner) => Traced(Traced(fx, inner), trace),
-      }
+) => Fx<R, E, A> = function Fx<R, E, A>(run: Fx<R, E, A>['run']): Fx<R, E, A> {
+  const fx: Fx<R, E, A> = {
+    [FxTypeId]: fxVariance,
+    run,
+  }
 
-      return fx
-    },
-)
+  return fx
+}
 
 export function Fx<R, E, A>(
   run: <R2>(sink: Sink<R2, E, A>) => Effect<R | R2, never, void>,
@@ -45,29 +39,10 @@ export function 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),
-    addTrace: (trace) => Traced(traced, trace),
-  }
-
-  return traced
-}
-
 export namespace Fx {
+  export type Any = Fx<any, any, any>
+  export type TupleAny = ReadonlyArray<Any>
+
   export type Cancel = Runtime.Cancel<never, void>
 
   export type ResourcesOf<T> = [T] extends [never]
@@ -99,8 +74,8 @@ export function Sink<A, R, E, R2>(
   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)),
+    event,
+    error,
   }
 }
 

package/src/RefArray.ts

@@ -0,0 +1,226 @@
+import { pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import * as Order from '@effect/data/Order'
+import * as ReadonlyArray from '@effect/data/ReadonlyArray'
+import * as Equivalence from '@effect/data/Equivalence'
+import * as Effect from '@effect/io/Effect'
+import * as Scope from '@effect/io/Scope'
+import fastDeepEqual from 'fast-deep-equal/es6'
+
+import { Computed } from './Computed.js'
+import { RefSubject, makeRef } from './RefSubject.js'
+
+export interface RefArray<E, A> extends RefSubject<E, readonly A[]> {
+  /**
+   * Append values to the end of the array contained within the RefSubject
+   */
+  readonly append: (...as: readonly A[]) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Returns true if the array contains the given value.
+   */
+  readonly contains: (a: A) => Effect.Effect<never, E, boolean>
+
+  /**
+   * Drops the first `n` values from the array contained within the RefSubject
+   */
+  readonly drop: (n: number) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Drops the last `n` values from the array contained within the RefSubject
+   */
+  readonly dropRight: (n: number) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Drops values from the array contained within the RefSubject as long as the predicate returns true
+   */
+  readonly dropWhile: (predicate: (a: A) => boolean) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Filter the values contained within the RefSubject.
+   */
+  readonly filterValues: (
+    predicate: (a: A, index: number) => boolean,
+  ) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Retrieve the value at a given index from the array contained within the RefSubject.
+   */
+  readonly getIndex: (index: number) => Effect.Effect<never, E, Option.Option<A>>
+
+  /**
+   * Creates a computed value which will group the values contained within the RefSubject by the given function.
+   */
+  readonly groupBy: (f: (a: A) => string) => Computed<never, E, Record<string, readonly A[]>>
+
+  /**
+   * Insert a value at the given index into the array contained within the RefSubject.
+   */
+  readonly insertAt: (index: number, a: A) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * A Computed value which will be true if the array contained within the RefSubject is empty.
+   */
+  readonly isEmpty: Computed<never, E, boolean>
+
+  /**
+   * A Computed value which will be true if the array contained within the RefSubject is not empty.
+   */
+  readonly isNonEmpty: Computed<never, E, boolean>
+
+  /**
+   * A Computed value which will be true if the array contained within the RefSubject is not empty.
+   */
+  readonly length: Computed<never, E, number>
+
+  /**
+   * Map the values of the array contained within the RefSubject into a Computed value which will
+   * always be kept up-to-date.
+   */
+  readonly mapValues: <B>(f: (a: A, index: number) => B) => Computed<never, E, readonly B[]>
+
+  /**
+   * Modify the value at a given index in the array contained within the RefSubject.
+   */
+  readonly modifyAt: (index: number, f: (a: A) => A) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Split the array contained within the RefSubject into two arrays, one which contains the values
+   * which satisfy the predicate and one which contains the values which do not.
+   */
+  readonly partition: (
+    predicate: (a: A, index: number) => boolean,
+  ) => Computed<never, E, readonly [readonly A[], readonly A[]]>
+
+  /**
+   * Prepend values to the beginning of the array contained within the RefSubject
+   */
+  readonly prepend: (...as: readonly A[]) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Reduce the values contained within the RefSubject into a single value returning a Computed
+   * which will always be kept up-to-date.
+   */
+  readonly reduce: <B>(b: B, f: (b: B, a: A, index: number) => B) => Computed<never, E, B>
+
+  /**
+   * Reduce the values, from last index to first, contained within the RefSubject into a single value returning a Computed
+   * which will always be kept up-to-date.
+   */
+  readonly reduceRight: <B>(b: B, f: (b: B, a: A, index: number) => B) => Computed<never, E, B>
+
+  /**
+   * Replace the value at a given index in the array contained within the RefSubject.
+   */
+  readonly replaceAt: (index: number, a: A) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Rotate the values in the array contained within the RefSubject by the given number of places.
+   * Very helpful for carousel-like functionality.
+   */
+  readonly rotate: (n: number) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Sort the values in the array contained within the RefSubject by the given ordering.
+   */
+  readonly sortBy: (...orders: Order.Order<A>[]) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Take the first `n` values from the array contained within the RefSubject
+   */
+  readonly take: (n: number) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Take the last `n` values from the array contained within the RefSubject
+   */
+  readonly takeRight: (n: number) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Take values from the array contained within the RefSubject as long as the predicate returns true
+   */
+  readonly takeWhile: (predicate: (a: A) => boolean) => Effect.Effect<never, E, readonly A[]>
+
+  /**
+   * Removes any duplicates held within the array contained within the RefSubject.
+   */
+  readonly dedupe: Effect.Effect<never, E, readonly A[]>
+}
+
+export function makeRefArray<R, E, A>(
+  initial: Effect.Effect<R, E, readonly A[]>,
+  eq: Equivalence.Equivalence<A> = fastDeepEqual,
+): Effect.Effect<R | Scope.Scope, never, RefArray<E, A>> {
+  return Effect.gen(function* ($) {
+    const arrayEq = Equivalence.array(eq)
+    const ref = yield* $(makeRef(initial, arrayEq))
+    const isEmpty = ref.map(ReadonlyArray.isEmptyReadonlyArray)
+    const isNonEmpty = ref.map(ReadonlyArray.isNonEmptyReadonlyArray)
+    const length = ref.map(ReadonlyArray.length)
+    const getIndex = (index: number) => ref.map(ReadonlyArray.get(index))
+    const prepend = (...as: readonly A[]) => ref.update(ReadonlyArray.prependAll(as))
+    const append = (...as: readonly A[]) => ref.update(ReadonlyArray.appendAll(as))
+    const insertAt = (index: number, a: A) =>
+      ref.update((as) =>
+        pipe(
+          as,
+          ReadonlyArray.insertAt(index, a),
+          Option.getOrElse(() => as),
+        ),
+      )
+    const replaceAt = (index: number, a: A) =>
+      ref.update((as) => pipe(as, ReadonlyArray.replace(index, a)))
+    const modifyAt = (index: number, f: (a: A) => A) => ref.update(ReadonlyArray.modify(index, f))
+    const take = (n: number) => ref.update(ReadonlyArray.take(n))
+    const takeRight = (n: number) => ref.update(ReadonlyArray.takeRight(n))
+    const drop = (n: number) => ref.update(ReadonlyArray.drop(n))
+    const dropRight = (n: number) => ref.update(ReadonlyArray.dropRight(n))
+    const takeWhile = (predicate: (a: A) => boolean) =>
+      ref.update(ReadonlyArray.takeWhile(predicate))
+    const dropWhile = (predicate: (a: A) => boolean) =>
+      ref.update(ReadonlyArray.dropWhile(predicate))
+    const sortBy = (...orders: Order.Order<A>[]) => ref.update(ReadonlyArray.sortBy<A>(...orders))
+    const rotate = (n: number) => ref.update(ReadonlyArray.rotate(n))
+    const contains_ = ReadonlyArray.containsWith(eq)
+    const contains = (a: A) => ref.map<boolean>(contains_(a))
+    const dedupe = ref.update(ReadonlyArray.dedupeWith(eq))
+    const groupBy = (f: (a: A) => string) => ref.map(ReadonlyArray.groupBy(f))
+    const filterValues = (predicate: (a: A, index: number) => boolean) =>
+      ref.update(ReadonlyArray.filter(predicate))
+    const partition = (predicate: (a: A, index: number) => boolean) =>
+      ref.map(ReadonlyArray.partition(predicate))
+
+    const mapValues = <B>(f: (a: A, index: number) => B) => ref.map(ReadonlyArray.map(f))
+    const reduce = <B>(b: B, f: (b: B, a: A, index: number) => B) =>
+      ref.map(ReadonlyArray.reduce(b, f))
+    const reduceRight = <B>(b: B, f: (b: B, a: A, index: number) => B) =>
+      ref.map(ReadonlyArray.reduceRight(b, f))
+
+    return Object.assign(ref, {
+      append,
+      contains,
+      drop,
+      dropRight,
+      dropWhile,
+      filterValues,
+      getIndex,
+      groupBy,
+      insertAt,
+      isEmpty,
+      isNonEmpty,
+      length,
+      mapValues,
+      modifyAt,
+      partition,
+      prepend,
+      reduce,
+      reduceRight,
+      replaceAt,
+      rotate,
+      sortBy,
+      take,
+      takeRight,
+      takeWhile,
+      dedupe,
+    })
+  })
+}

package/src/RefSubject.test.ts

@@ -20,7 +20,7 @@ describe('RefSubject', () => {
         deepStrictEqual(value, 1)
       })
 
-      await Effect.runPromise(test)
+      await Effect.runPromise(Effect.scoped(test))
     })
   })
 
@@ -33,7 +33,7 @@ describe('RefSubject', () => {
         deepStrictEqual(yield* $(ref.get), 2)
       })
 
-      await Effect.runPromise(test)
+      await Effect.runPromise(Effect.scoped(test))
     })
   })
 
@@ -46,7 +46,7 @@ describe('RefSubject', () => {
         deepStrictEqual(yield* $(ref.get), 2)
       })
 
-      await Effect.runPromise(test)
+      await Effect.runPromise(Effect.scoped(test))
     })
   })
 
@@ -59,7 +59,7 @@ describe('RefSubject', () => {
         deepStrictEqual(yield* $(ref.get), 2)
       })
 
-      await Effect.runPromise(test)
+      await Effect.runPromise(Effect.scoped(test))
     })
   })
 
@@ -78,7 +78,7 @@ describe('RefSubject', () => {
         deepStrictEqual(yield* $(ref.delete), Option.some(1))
       })
 
-      await Effect.runPromise(test)
+      await Effect.runPromise(Effect.scoped(test))
     })
   })
 
@@ -146,6 +146,67 @@ describe('RefSubject', () => {
 
         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)
+      })
     })
   })
 
@@ -350,7 +411,7 @@ describe('RefSubject', () => {
         deepStrictEqual(yield* $(c.get), 4)
       })
 
-      await Effect.runPromise(test)
+      await Effect.runPromise(Effect.scoped(test))
     })
   })
 })