@typed/fx 2.0.0-beta.1 → 2.0.0-beta.3

package/src/Fx/run/observe.ts

@@ -4,7 +4,7 @@ import {
   callback,
   catchCause,
   failCause,
-  forkChild,
+  forkScoped,
   isEffect,
   matchCauseEffect,
   runForkWith,
@@ -84,7 +84,7 @@ export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect<void, E, R> => observe(f
  * @category runners
  */
 export const drainLayer = <A, E, R>(fx: Fx<A, E, R>): Layer<never, E, Exclude<R, Scope>> =>
-  effectDiscard(forkChild(drain(fx)));
+  effectDiscard(forkScoped(drain(fx)));
 
 /**
  * Observes the values of an `Fx` stream using a callback function and returns a `Layer`.
@@ -110,5 +110,5 @@ export const observeLayer: {
   <A, E, R, E2 = never, R2 = never>(
     fx: Fx<A, E, R>,
     f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): Layer<never, E | E2, Exclude<R | R2, Scope>> => effectDiscard(observe(fx, f)),
+  ): Layer<never, E | E2, Exclude<R | R2, Scope>> => effectDiscard(forkScoped(observe(fx, f))),
 );

package/src/RefSubject/RefArray.ts

@@ -14,6 +14,7 @@ import type * as Order from "effect/Order";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefArray is a RefSubject that is specialized over an array of values.
@@ -210,10 +211,7 @@ export const insertAt: {
   <A, E, R>(ref: RefArray<A, E, R>, index: number, a: A): Effect.Effect<ReadonlyArray<A>, E, R>;
 } = dual(3, function insertAt<A, E, R>(ref: RefArray<A, E, R>, index: number, a: A) {
   return RefSubject.update(ref, (as) =>
-    Option.getOrElse(Option.fromUndefinedOr(ReadonlyArray.insertAt(as, index, a)), () => [
-      ...as,
-      a,
-    ]),
+    Option.getOrElse(ReadonlyArray.insertAt(as, index, a), () => [...as, a]),
   );
 });
 
@@ -291,7 +289,9 @@ export const modifyAt: {
     f: (a: A) => A,
   ): Effect.Effect<ReadonlyArray<A>, E, R>;
 } = dual(3, function modifyAt<A, E, R>(ref: RefArray<A, E, R>, index: number, f: (a: A) => A) {
-  return RefSubject.update(ref, (values) => ReadonlyArray.modify(values, index, f) || values);
+  return RefSubject.update(ref, (values) =>
+    Option.getOrElse(ReadonlyArray.modify(values, index, f), () => values),
+  );
 });
 
 /**
@@ -310,7 +310,9 @@ export const partition: {
     predicate: (a: A) => boolean,
   ): RefSubject.Computed<never, E, readonly [ReadonlyArray<A>, ReadonlyArray<A>]>;
 } = dual(2, function partition<A, E, R>(ref: RefArray<A, E, R>, predicate: (a: A) => boolean) {
-  return RefSubject.map(ref, ReadonlyArray.partition(predicate));
+  return RefSubject.map(ref, (array) =>
+    ReadonlyArray.partition(array, Result.liftPredicate(predicate, Result.fail)),
+  );
 });
 
 /**
@@ -370,7 +372,9 @@ export const replaceAt: {
   <A>(index: number, a: A): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
   <A, E, R>(ref: RefArray<A, E, R>, index: number, a: A): Effect.Effect<ReadonlyArray<A>, E, R>;
 } = dual(3, function replaceAt<A, E, R>(ref: RefArray<A, E, R>, index: number, a: A) {
-  return RefSubject.update(ref, (values) => ReadonlyArray.replace(values, index, a) || values);
+  return RefSubject.update(ref, (values) =>
+    Option.getOrElse(ReadonlyArray.replace(values, index, a), () => values),
+  );
 });
 
 /**

package/src/RefSubject/RefChunk.ts

@@ -8,10 +8,12 @@ import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import type { Equivalence } from "effect/Equivalence";
 import { dual } from "effect/Function";
+import * as Option from "effect/Option";
 import type * as Order from "effect/Order";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefChunk is a RefSubject specialized over a Chunk of values.
@@ -182,7 +184,9 @@ export const modifyAt: {
     f: (a: A) => A,
   ): Effect.Effect<Chunk.Chunk<A>, E, R>;
 } = dual(3, function modifyAt<A, E, R>(ref: RefChunk<A, E, R>, index: number, f: (a: A) => A) {
-  return RefSubject.update(ref, (chunk) => Chunk.modify(chunk, index, f) ?? chunk);
+  return RefSubject.update(ref, (chunk) =>
+    Option.getOrElse(Chunk.modify(chunk, index, f), () => chunk),
+  );
 });
 
 /**
@@ -194,7 +198,9 @@ export const replaceAt: {
   <A>(index: number, a: A): <E, R>(ref: RefChunk<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R>;
   <A, E, R>(ref: RefChunk<A, E, R>, index: number, a: A): Effect.Effect<Chunk.Chunk<A>, E, R>;
 } = dual(3, function replaceAt<A, E, R>(ref: RefChunk<A, E, R>, index: number, a: A) {
-  return RefSubject.update(ref, (chunk) => Chunk.replace(chunk, index, a) ?? chunk);
+  return RefSubject.update(ref, (chunk) =>
+    Option.getOrElse(Chunk.replace(chunk, index, a), () => chunk),
+  );
 });
 
 /**
@@ -356,7 +362,7 @@ export const partition: {
     predicate: (a: A) => boolean,
   ): RefSubject.Computed<[Chunk.Chunk<A>, Chunk.Chunk<A>], E, R>;
 } = dual(2, function partition<A, E, R>(ref: RefChunk<A, E, R>, predicate: (a: A) => boolean) {
-  return RefSubject.map(ref, Chunk.partition(predicate));
+  return RefSubject.map(ref, Chunk.partition(Result.liftPredicate(predicate, Result.fail)));
 });
 
 /**

package/src/RefSubject/RefDateTime.test.ts

@@ -10,21 +10,21 @@ describe("RefDateTime", () => {
       const value = DateTime.nowUnsafe();
       const ref = yield* RefDateTime.make(value);
       const current = yield* ref;
-      expect(current.epochMillis).toBe(value.epochMillis);
+      expect(DateTime.toEpochMillis(current)).toBe(DateTime.toEpochMillis(value));
     }).pipe(Effect.scoped, Effect.runPromise));
 
   it("adds duration", () =>
     Effect.gen(function* () {
       const ref = yield* RefDateTime.make(DateTime.makeUnsafe(0));
       const result = yield* RefDateTime.addDuration(ref, Duration.seconds(5));
-      expect(result.epochMillis).toBe(5000);
+      expect(DateTime.toEpochMillis(result)).toBe(5000);
     }).pipe(Effect.scoped, Effect.runPromise));
 
   it("subtracts duration", () =>
     Effect.gen(function* () {
       const ref = yield* RefDateTime.make(DateTime.makeUnsafe(10000));
       const result = yield* RefDateTime.subtractDuration(ref, Duration.seconds(3));
-      expect(result.epochMillis).toBe(7000);
+      expect(DateTime.toEpochMillis(result)).toBe(7000);
     }).pipe(Effect.scoped, Effect.runPromise));
 
   it("gets epoch milliseconds", () =>

package/src/RefSubject/RefDateTime.ts

@@ -183,10 +183,7 @@ export const subtractDuration: {
     ref: RefDateTime<E, R>,
     duration: Duration.Input,
   ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(2, function subtractDuration<
-  E,
-  R,
->(ref: RefDateTime<E, R>, duration: Duration.Input) {
+} = dual(2, function subtractDuration<E, R>(ref: RefDateTime<E, R>, duration: Duration.Input) {
   return RefSubject.map(ref, (self) => DateTime.subtractDuration(self, duration));
 });
 
@@ -196,7 +193,7 @@ export const subtractDuration: {
  * @category computed
  */
 export const epochMillis = <E, R>(ref: RefDateTime<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, (self) => self.epochMillis);
+  RefSubject.map(ref, (self) => DateTime.toEpochMillis(self));
 
 /**
  * Format the current state of a RefDateTime.

package/src/RefSubject/RefGraph.ts

@@ -7,7 +7,6 @@ import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
 import * as Graph from "effect/Graph";
-import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
@@ -596,7 +595,7 @@ export const getEdge: {
   Err,
   R,
 >(ref: RefGraph<N, E, T, Err, R>, edgeIndex: Graph.EdgeIndex) {
-  return RefSubject.filterMap(ref, (g) => Option.fromUndefinedOr(Graph.getEdge(g, edgeIndex)));
+  return RefSubject.filterMap(ref, (g) => Graph.getEdge(g, edgeIndex));
 });
 
 /**
@@ -621,7 +620,7 @@ export const findNode: {
   Err,
   R,
 >(ref: RefGraph<N, E, T, Err, R>, predicate: (data: N) => boolean) {
-  return RefSubject.filterMap(ref, (g) => Option.fromUndefinedOr(Graph.findNode(g, predicate)));
+  return RefSubject.filterMap(ref, (g) => Graph.findNode(g, predicate));
 });
 
 /**
@@ -646,5 +645,5 @@ export const findEdge: {
   Err,
   R,
 >(ref: RefGraph<N, E, T, Err, R>, predicate: (edge: E) => boolean) {
-  return RefSubject.filterMap(ref, (g) => Option.fromUndefinedOr(Graph.findEdge(g, predicate)));
+  return RefSubject.filterMap(ref, (g) => Graph.findEdge(g, predicate));
 });

package/src/RefSubject/RefHashMap.ts

@@ -5,12 +5,13 @@
 
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
-import { dual, flow } from "effect/Function";
+import { dual } from "effect/Function";
 import * as HashMap from "effect/HashMap";
 import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefHashMap is a RefSubject specialized over a HashMap.
@@ -354,7 +355,15 @@ export const filterMapValues: {
   R,
   B,
 >(ref: RefHashMap<K, V, E, R>, f: (value: V, key: K) => Option.Option<B>) {
-  return RefSubject.map(ref, HashMap.filterMap(f));
+  return RefSubject.map(
+    ref,
+    HashMap.filterMap((value, key) =>
+      Option.match(f(value, key), {
+        onNone: () => Result.failVoid,
+        onSome: (b) => Result.succeed(b),
+      }),
+    ),
+  );
 });
 
 /**
@@ -461,5 +470,5 @@ export const findFirst: {
   E,
   R,
 >(ref: RefHashMap<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.filterMap(ref, flow(HashMap.findFirst(predicate), Option.fromUndefinedOr));
+  return RefSubject.filterMap(ref, (g) => HashMap.findFirst(g, predicate));
 });

package/src/RefSubject/RefIterable.ts

@@ -3,11 +3,12 @@
  * @since 1.18.0
  */
 
+import { Result } from "effect";
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
 import * as Iterable from "effect/Iterable";
-import type * as Option from "effect/Option";
+import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
@@ -233,7 +234,15 @@ export const filterMap: {
   E,
   R,
 >(ref: RefIterable<A, E, R>, f: (a: A, index: number) => Option.Option<A>) {
-  return RefSubject.update(ref, Iterable.filterMap(f));
+  return RefSubject.update(
+    ref,
+    Iterable.filterMap((a, index) =>
+      Option.match(f(a, index), {
+        onNone: () => Result.failVoid,
+        onSome: (b) => Result.succeed(b),
+      }),
+    ),
+  );
 });
 
 /**

package/src/RefSubject/RefRecord.ts

@@ -3,6 +3,7 @@
  * @since 1.18.0
  */
 
+import { Result } from "effect";
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
@@ -99,7 +100,7 @@ export const modify: {
   E,
   R,
 >(ref: RefRecord<K, V, E, R>, key: K, f: (v: V) => V) {
-  return RefSubject.update(ref, (r) => Record.modify(r, key, f) ?? r);
+  return RefSubject.update(ref, (r) => Option.getOrElse(Record.modify(r, key, f), () => r));
 });
 
 /**
@@ -123,7 +124,7 @@ export const replace: {
   E,
   R,
 >(ref: RefRecord<K, V, E, R>, key: K, value: V) {
-  return RefSubject.update(ref, (r) => Record.replace(r, key, value) ?? r);
+  return RefSubject.update(ref, (r) => Option.getOrElse(Record.replace(r, key, value), () => r));
 });
 
 /**
@@ -450,7 +451,11 @@ export const filterMapValues: {
   R,
   B,
 >(ref: RefRecord<K, V, E, R>, f: (value: V, key: K) => Option.Option<B>) {
-  return RefSubject.map(ref, (r) => Record.filterMap(r, f) as Record.ReadonlyRecord<K, B>);
+  return RefSubject.map(ref, (r) =>
+    Record.filterMap(r, (value, key) =>
+      f(value, key) ? Result.succeed(value) : Result.fail(value),
+    ),
+  );
 });
 
 /**
@@ -477,7 +482,9 @@ export const partition: {
   return RefSubject.map(
     ref,
     (r) =>
-      Record.partition(r, predicate) as [Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>],
+      Record.partition(r, (value, key) =>
+        predicate(value, key) ? Result.succeed(value) : Result.fail(value),
+      ) as [Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>],
   );
 });
 
@@ -585,7 +592,7 @@ export const findFirst: {
   E,
   R,
 >(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.filterMap(ref, (r) => Option.fromNullishOr(Record.findFirst(r, predicate)));
+  return RefSubject.filterMap(ref, (r) => Record.findFirst(r, predicate));
 });
 
 /**
@@ -605,8 +612,10 @@ export const pop: {
   ): RefSubject.Filtered<[V, Record.ReadonlyRecord<K, V>], E, R>;
 } = dual(2, function pop<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K) {
   return RefSubject.filterMap(ref, (r) => {
-    const result = Record.pop(r, key);
-    if (result === undefined) return Option.none();
-    return Option.some([result[0], result[1] as Record.ReadonlyRecord<K, V>]);
+    return Option.map(
+      Record.pop(r, key),
+      ([value, next]) =>
+        [value, next as Record.ReadonlyRecord<K, V>] as [V, Record.ReadonlyRecord<K, V>],
+    );
   });
 });

package/src/RefSubject/RefSubject.ts

@@ -1240,12 +1240,10 @@ export const runUpdates: {
   <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(
     ref: RefSubject<A, E, R>,
     f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>,
-    options?:
-      | {
-          readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
-          readonly value?: "initial" | "current";
-        }
-      | undefined,
+    options?: {
+      readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+      readonly value?: "initial" | "current";
+    },
   ): Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
 } = dual(
   isRefSubjectDataFirst,

package/src/RefSubject/RefTrie.ts

@@ -6,11 +6,12 @@
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
-import type * as Option from "effect/Option";
+import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import * as Trie from "effect/Trie";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefTrie is a RefSubject specialized over a Trie.
@@ -122,13 +123,13 @@ export const clear = <V, E, R>(ref: RefTrie<V, E, R>): Effect.Effect<Trie.Trie<V
 export const map: {
   <V>(
     f: (value: V, key: string) => V,
-  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<V>, E, R>;
   <V, E, R>(
     ref: RefTrie<V, E, R>,
     f: (value: V, key: string) => V,
-  ): Effect.Effect<Trie.Trie<V>, E, R>;
+  ): RefSubject.Computed<Trie.Trie<V>, E, R>;
 } = dual(2, function map<V, E, R>(ref: RefTrie<V, E, R>, f: (value: V, key: string) => V) {
-  return RefSubject.update(ref, Trie.map(f));
+  return RefSubject.map(ref, Trie.map(f));
 });
 
 /**
@@ -139,17 +140,17 @@ export const map: {
 export const filter: {
   <V>(
     predicate: (value: V, key: string) => boolean,
-  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<V>, E, R>;
   <V, E, R>(
     ref: RefTrie<V, E, R>,
     predicate: (value: V, key: string) => boolean,
-  ): Effect.Effect<Trie.Trie<V>, E, R>;
+  ): RefSubject.Computed<Trie.Trie<V>, E, R>;
 } = dual(2, function filter<
   V,
   E,
   R,
 >(ref: RefTrie<V, E, R>, predicate: (value: V, key: string) => boolean) {
-  return RefSubject.update(ref, Trie.filter(predicate));
+  return RefSubject.map(ref, Trie.filter(predicate));
 });
 
 /**
@@ -160,17 +161,25 @@ export const filter: {
 export const filterMap: {
   <V>(
     f: (value: V, key: string) => Option.Option<V>,
-  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<V>, E, R>;
   <V, E, R>(
     ref: RefTrie<V, E, R>,
     f: (value: V, key: string) => Option.Option<V>,
-  ): Effect.Effect<Trie.Trie<V>, E, R>;
+  ): RefSubject.Computed<Trie.Trie<V>, E, R>;
 } = dual(2, function filterMap<
   V,
   E,
   R,
 >(ref: RefTrie<V, E, R>, f: (value: V, key: string) => Option.Option<V>) {
-  return RefSubject.update(ref, Trie.filterMap(f));
+  return RefSubject.map(
+    ref,
+    Trie.filterMap((value, key) =>
+      Option.match(f(value, key), {
+        onNone: () => Result.failVoid,
+        onSome: (b) => Result.succeed(b),
+      }),
+    ),
+  );
 });
 
 // ========================================