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

package/src/RefSubject/RefBoolean.ts

@@ -1,185 +0,0 @@
-/**
- * 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

@@ -1,53 +0,0 @@
-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

@@ -1,146 +0,0 @@
-/**
- * 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);