@typed/fx 1.31.0 → 2.0.0-beta.0

package/src/RefSubject/RefBoolean.ts

@@ -0,0 +1,185 @@
+/**
+ * Extensions to RefSubject for working with boolean values
+ * @since 1.18.0
+ */
+
+import * as Boolean_ from "effect/Boolean";
+import type * as Effect from "effect/Effect";
+import * as Equivalence_ from "effect/Equivalence";
+import type { Equivalence } from "effect/Equivalence";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import type * as Fx from "../Fx/index.js";
+import * as RefSubject from "./RefSubject.js";
+
+/**
+ * A RefBoolean is a RefSubject specialized over a boolean value.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefBoolean<in out E = never, out R = never> extends RefSubject.RefSubject<
+  boolean,
+  E,
+  R
+> {}
+
+/**
+ * Creates a new `RefBoolean` from a boolean, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefBoolean from "effect/typed/fx/RefSubject/RefBoolean"
+ *
+ * const program = Effect.gen(function* () {
+ *   const value = yield* RefBoolean.make(true)
+ *   const current = yield* value
+ *   console.log(current) // true
+ * })
+ * ```
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<E = never, R = never>(
+  initial: boolean | Effect.Effect<boolean, E, R> | Fx.Fx<boolean, E, R>,
+  eq: Equivalence<boolean> = Equivalence_.strictEqual(),
+): Effect.Effect<RefBoolean<E>, never, R | Scope.Scope> {
+  return RefSubject.make(initial, { eq });
+}
+
+/**
+ * Toggle the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const toggle = <E, R>(ref: RefBoolean<E, R>): Effect.Effect<boolean, E, R> =>
+  RefSubject.update(ref, Boolean_.not);
+
+/**
+ * Set the current state of a RefBoolean to true.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const setTrue = <E, R>(ref: RefBoolean<E, R>): Effect.Effect<boolean, E, R> =>
+  RefSubject.set(ref, true);
+
+/**
+ * Set the current state of a RefBoolean to false.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const setFalse = <E, R>(ref: RefBoolean<E, R>): Effect.Effect<boolean, E, R> =>
+  RefSubject.set(ref, false);
+
+// ========================================
+// Computed
+// ========================================
+
+/**
+ * Apply AND operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const and: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function and<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.and(self, that));
+});
+
+/**
+ * Apply OR operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const or: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function or<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.or(self, that));
+});
+
+/**
+ * Apply NOT operation to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const not = <E, R>(ref: RefBoolean<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, Boolean_.not);
+
+/**
+ * Apply XOR operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const xor: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function xor<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.xor(self, that));
+});
+
+/**
+ * Apply NAND operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const nand: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function nand<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.nand(self, that));
+});
+
+/**
+ * Apply NOR operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const nor: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function nor<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.nor(self, that));
+});
+
+/**
+ * Apply EQV (XNOR) operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const eqv: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function eqv<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.eqv(self, that));
+});
+
+/**
+ * Apply implication operation with a boolean to the current state of a RefBoolean.
+ * @since 1.18.0
+ * @category computed
+ */
+export const implies: {
+  (that: boolean): <E, R>(ref: RefBoolean<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBoolean<E, R>, that: boolean): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function implies<E, R>(ref: RefBoolean<E, R>, that: boolean) {
+  return RefSubject.map(ref, (self) => Boolean_.implies(self, that));
+});
+
+/**
+ * Check if the current state of a RefBoolean is true.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isTrue = <E, R>(ref: RefBoolean<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, (self) => self === true);
+
+/**
+ * Check if the current state of a RefBoolean is false.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isFalse = <E, R>(ref: RefBoolean<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, (self) => self === false);

package/src/RefSubject/RefCause.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import * as Cause from "effect/Cause";
+import type * as Scope from "effect/Scope";
+import * as RefCause from "./RefCause.js";
+
+describe("RefCause", () => {
+  it("creates and gets value", () =>
+    Effect.gen(function* () {
+      const value = Cause.fail("error");
+      const ref = yield* RefCause.make(value);
+      const current = yield* ref;
+      expect(Cause.hasFails(current)).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sets Fail cause", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefCause.make<string, unknown, Scope.Scope>(Cause.empty);
+      yield* RefCause.setFail(ref, "error");
+      const result = yield* ref;
+      expect(Cause.hasFails(result)).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sets Die cause", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefCause.make(Cause.empty);
+      yield* RefCause.setDie(ref, new Error("defect"));
+      const result = yield* ref;
+      expect(Cause.hasDies(result)).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sets Interrupt cause", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefCause.make(Cause.empty);
+      yield* RefCause.setInterrupt(ref, 123);
+      const result = yield* ref;
+      expect(Cause.hasInterrupts(result)).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("checks if has Fail", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefCause.make(Cause.fail("error"));
+      const hasFail = yield* RefCause.hasFails(ref);
+      expect(hasFail).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("checks size", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefCause.make(Cause.fail("error"));
+      const size = yield* RefCause.size(ref);
+      expect(size).toBe(1);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/RefSubject/RefCause.ts

@@ -0,0 +1,146 @@
+/**
+ * Extensions to RefSubject for working with Cause values
+ * @since 1.18.0
+ */
+
+import * as Cause from "effect/Cause";
+import type * as Effect from "effect/Effect";
+import { equals } from "effect/Equal";
+import * as Equivalence_ from "effect/Equivalence";
+import type { Equivalence } from "effect/Equivalence";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import type * as Fx from "../Fx/index.js";
+import * as RefSubject from "./RefSubject.js";
+
+/**
+ * A RefCause is a RefSubject specialized over a Cause value.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefCause<
+  in out E,
+  in out Err = never,
+  out R = never,
+> extends RefSubject.RefSubject<Cause.Cause<E>, Err, R> {}
+
+/**
+ * Creates a new `RefCause` from a Cause, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Cause } from "effect"
+ * import * as RefCause from "effect/typed/fx/RefSubject/RefCause"
+ *
+ * const program = Effect.gen(function* () {
+ *   const value = yield* RefCause.make(Cause.fail("error"))
+ *   const current = yield* value
+ *   console.log(current) // Cause(...)
+ * })
+ * ```
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<E = never, Err = never, R = never>(
+  initial: Cause.Cause<E> | Effect.Effect<Cause.Cause<E>, Err, R> | Fx.Fx<Cause.Cause<E>, Err, R>,
+  eq: Equivalence<Cause.Cause<E>> = equals,
+): Effect.Effect<RefCause<E, Err>, never, R | Scope.Scope> {
+  return RefSubject.make(initial, { eq: Equivalence_.make(eq) });
+}
+
+/**
+ * Set the current state of a RefCause to a Fail cause.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const setFail: {
+  <E>(error: E): <Err, R>(ref: RefCause<E, Err, R>) => Effect.Effect<Cause.Cause<E>, Err, R>;
+  <E, Err, R>(ref: RefCause<E, Err, R>, error: E): Effect.Effect<Cause.Cause<E>, Err, R>;
+} = dual(2, function setFail<E, Err, R>(ref: RefCause<E, Err, R>, error: E) {
+  return RefSubject.set(ref, Cause.fail(error));
+});
+
+/**
+ * Set the current state of a RefCause to a Die cause.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const setDie: {
+  (defect: unknown): <E, Err, R>(ref: RefCause<E, Err, R>) => Effect.Effect<Cause.Cause<E>, Err, R>;
+  <E, Err, R>(ref: RefCause<E, Err, R>, defect: unknown): Effect.Effect<Cause.Cause<E>, Err, R>;
+} = dual(2, function setDie<E, Err, R>(ref: RefCause<E, Err, R>, defect: unknown) {
+  return RefSubject.set(ref, Cause.die(defect));
+});
+
+/**
+ * Set the current state of a RefCause to an Interrupt cause.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const setInterrupt: {
+  (
+    fiberId?: number,
+  ): <E, Err, R>(ref: RefCause<E, Err, R>) => Effect.Effect<Cause.Cause<E>, Err, R>;
+  <E, Err, R>(ref: RefCause<E, Err, R>, fiberId?: number): Effect.Effect<Cause.Cause<E>, Err, R>;
+} = dual(2, function setInterrupt<E, Err, R>(ref: RefCause<E, Err, R>, fiberId?: number) {
+  return RefSubject.set(ref, Cause.interrupt(fiberId));
+});
+
+// ========================================
+// Computed
+// ========================================
+
+/**
+ * Check if the current state of a RefCause has a Fail.
+ * @since 1.18.0
+ * @category computed
+ */
+export const hasFails = <E, Err, R>(
+  ref: RefCause<E, Err, R>,
+): RefSubject.Computed<boolean, Err, R> => RefSubject.map(ref, Cause.hasFails);
+
+/**
+ * Check if the current state of a RefCause has a Die.
+ * @since 1.18.0
+ * @category computed
+ */
+export const hasDies = <E, Err, R>(
+  ref: RefCause<E, Err, R>,
+): RefSubject.Computed<boolean, Err, R> => RefSubject.map(ref, Cause.hasDies);
+
+/**
+ * Check if the current state of a RefCause has an Interrupt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const hasInterrupts = <E, Err, R>(
+  ref: RefCause<E, Err, R>,
+): RefSubject.Computed<boolean, Err, R> => RefSubject.map(ref, Cause.hasInterrupts);
+
+/**
+ * Check if the current state of a RefCause is empty.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isEmpty = <E, Err, R>(
+  ref: RefCause<E, Err, R>,
+): RefSubject.Computed<boolean, Err, R> => RefSubject.map(ref, (self) => self.reasons.length === 0);
+
+/**
+ * Get the size (number of failures) of the current state of a RefCause.
+ * @since 1.18.0
+ * @category computed
+ */
+export const size = <E, Err, R>(ref: RefCause<E, Err, R>): RefSubject.Computed<number, Err, R> =>
+  RefSubject.map(ref, (self) => self.reasons.length);
+
+/**
+ * Get the reasons array of the current state of a RefCause.
+ * @since 1.18.0
+ * @category computed
+ */
+export const reasons = <E, Err, R>(
+  ref: RefCause<E, Err, R>,
+): RefSubject.Computed<ReadonlyArray<Cause.Reason<E>>, Err, R> =>
+  RefSubject.map(ref, (self) => self.reasons);