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

package/dist/RefSubject/RefBigDecimal.js

@@ -8,10 +8,21 @@ import * as RefSubject from "./RefSubject.js";
 /**
  * Creates a new `RefBigDecimal` from a BigDecimal, `Effect`, or `Fx`.
  *
+ * @remarks
+ * ## Why
+ *
+ * Creates big decimal state with equality suited to that Effect data type, so unchanged values do
+ * not produce redundant pushed updates.
+ *
+ * ## Ownership and lifetime
+ *
+ * The creation Effect requires Scope. It owns initializer acquisition, live source subscriptions,
+ * and cleanup; source failures and services stay on reads and pushes.
+ *
  * @example
  * ```ts
  * import { Effect, BigDecimal } from "effect"
- * import * as RefBigDecimal from "effect/typed/fx/RefSubject/RefBigDecimal"
+ * import * as RefBigDecimal from "@typed/fx/RefBigDecimal"
  *
  * const program = Effect.gen(function* () {
  *   const value = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("123.45"))
@@ -21,7 +32,7 @@ import * as RefSubject from "./RefSubject.js";
  * ```
  *
  * @since 1.18.0
- * @category constructors
+ * @category Constructors
  */
 export function make(initial) {
     return RefSubject.make(initial, { eq: BigDecimal.Equivalence });
@@ -31,130 +42,328 @@ export function make(initial) {
 // ========================================
 /**
  * Add a BigDecimal to the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Add a BigDecimal to the current state of a RefBigDecimal. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The add view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const add = dual(2, function add(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.sum(self, that));
 });
 /**
  * Subtract a BigDecimal from the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Subtract a BigDecimal from the current state of a RefBigDecimal. The operation remains attached
+ * to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The subtract view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const subtract = dual(2, function subtract(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.subtract(self, that));
 });
 /**
  * Multiply the current state of a RefBigDecimal by a BigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Multiply the current state of a RefBigDecimal by a BigDecimal. The operation remains attached to
+ * the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The multiply view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const multiply = dual(2, function multiply(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.multiply(self, that));
 });
 /**
  * Divide the current state of a RefBigDecimal by a BigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Divide the current state of a RefBigDecimal by a BigDecimal. The operation remains attached to
+ * the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The divide view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const divide = dual(2, function divide(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.divide(self, that));
 });
 /**
  * Get the absolute value of the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Get the absolute value of the current state of a RefBigDecimal. The operation remains attached
+ * to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The abs view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const abs = (ref) => RefSubject.map(ref, BigDecimal.abs);
 /**
  * Negate the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Negate the current state of a RefBigDecimal. The operation remains attached to the RefSubject's
+ * versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The negate view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const negate = (ref) => RefSubject.map(ref, BigDecimal.negate);
 /**
  * Round the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Round the current state of a RefBigDecimal. The operation remains attached to the RefSubject's
+ * versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The round view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const round = dual(2, function round(ref, options) {
     return RefSubject.map(ref, (self) => BigDecimal.round(self, options));
 });
 /**
  * Truncate the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Truncate the current state of a RefBigDecimal. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The truncate view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const truncate = dual(2, function truncate(ref, scale) {
     return RefSubject.map(ref, (self) => BigDecimal.truncate(self, scale));
 });
 /**
  * Calculate the ceiling of the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Calculate the ceiling of the current state of a RefBigDecimal. The operation remains attached to
+ * the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The ceil view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const ceil = dual(2, function ceil(ref, scale) {
     return RefSubject.map(ref, (self) => BigDecimal.ceil(self, scale));
 });
 /**
  * Calculate the floor of the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Calculate the floor of the current state of a RefBigDecimal. The operation remains attached to
+ * the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The floor view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const floor = dual(2, function floor(ref, scale) {
     return RefSubject.map(ref, (self) => BigDecimal.floor(self, scale));
 });
 /**
  * Check if the current state of a RefBigDecimal is zero.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal is zero. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is zero view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export const isZero = (ref) => RefSubject.map(ref, BigDecimal.isZero);
 /**
  * Check if the current state of a RefBigDecimal is negative.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal is negative. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is negative view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export const isNegative = (ref) => RefSubject.map(ref, BigDecimal.isNegative);
 /**
  * Check if the current state of a RefBigDecimal is positive.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal is positive. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is positive view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export const isPositive = (ref) => RefSubject.map(ref, BigDecimal.isPositive);
 /**
  * Check if the current state of a RefBigDecimal is an integer.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal is an integer. The operation remains attached to
+ * the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is integer view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export const isInteger = (ref) => RefSubject.map(ref, BigDecimal.isInteger);
 /**
  * Get the sign of the current state of a RefBigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Get the sign of the current state of a RefBigDecimal. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The sign view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Derived queries
  */
 export const sign = (ref) => RefSubject.map(ref, BigDecimal.sign);
 /**
  * Check if the current state of a RefBigDecimal is less than a BigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal is less than a BigDecimal. The operation remains
+ * attached to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is less than view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export const isLessThan = dual(2, function isLessThan(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.isLessThan(self, that));
 });
 /**
  * Check if the current state of a RefBigDecimal is greater than a BigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal is greater than a BigDecimal. The operation
+ * remains attached to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is greater than view retains no independent state. An Effect read samples the source once;
+ * Fx observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export const isGreaterThan = dual(2, function isGreaterThan(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.isGreaterThan(self, that));
 });
 /**
  * Check if the current state of a RefBigDecimal equals a BigDecimal.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigDecimal equals a BigDecimal. The operation remains
+ * attached to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The equals view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export const equals = dual(2, function equals(ref, that) {
     return RefSubject.map(ref, (self) => BigDecimal.equals(self, that));

package/dist/RefSubject/RefBigInt.d.ts

@@ -9,18 +9,40 @@ import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
 /**
  * A RefBigInt is a RefSubject specialized over a BigInt value.
+ * @remarks
+ * ## Why
+ *
+ * Defines big int state with the same current-read, pushed-update, and synchronized-write contract
+ * as RefSubject.
+ *
+ * ## Ownership and lifetime
+ *
+ * RefBigInt is a contract and performs no acquisition. Implementations retain the errors,
+ * services, interruption, and Scope requirements expressed by its members.
+ *
  * @since 1.18.0
- * @category models
+ * @category State models
  */
 export interface RefBigInt<in out E = never, out R = never> extends RefSubject.RefSubject<bigint, E, R> {
 }
 /**
  * Creates a new `RefBigInt` from a BigInt, `Effect`, or `Fx`.
  *
+ * @remarks
+ * ## Why
+ *
+ * Creates big int state with equality suited to that Effect data type, so unchanged values do not
+ * produce redundant pushed updates.
+ *
+ * ## Ownership and lifetime
+ *
+ * The creation Effect requires Scope. It owns initializer acquisition, live source subscriptions,
+ * and cleanup; source failures and services stay on reads and pushes.
+ *
  * @example
  * ```ts
  * import { Effect, BigInt } from "effect"
- * import * as RefBigInt from "effect/typed/fx/RefSubject/RefBigInt"
+ * import * as RefBigInt from "@typed/fx/RefBigInt"
  *
  * const program = Effect.gen(function* () {
  *   const value = yield* RefBigInt.make(BigInt.BigInt(123))
@@ -30,13 +52,24 @@ export interface RefBigInt<in out E = never, out R = never> extends RefSubject.R
  * ```
  *
  * @since 1.18.0
- * @category constructors
+ * @category Constructors
  */
 export declare function make<E = never, R = never>(initial: bigint | Effect.Effect<bigint, E, R> | Fx.Fx<bigint, E, R>, eq?: Equivalence<bigint>): Effect.Effect<RefBigInt<E>, never, R | Scope.Scope>;
 /**
  * Add a BigInt to the current state of a RefBigInt.
+ * @remarks
+ * ## Why
+ *
+ * Add a BigInt to the current state of a RefBigInt. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The add view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const add: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
@@ -44,8 +77,19 @@ export declare const add: {
 };
 /**
  * Subtract a BigInt from the current state of a RefBigInt.
+ * @remarks
+ * ## Why
+ *
+ * Subtract a BigInt from the current state of a RefBigInt. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The subtract view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const subtract: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
@@ -53,8 +97,19 @@ export declare const subtract: {
 };
 /**
  * Multiply the current state of a RefBigInt by a BigInt.
+ * @remarks
+ * ## Why
+ *
+ * Multiply the current state of a RefBigInt by a BigInt. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The multiply view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const multiply: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
@@ -62,8 +117,19 @@ export declare const multiply: {
 };
 /**
  * Divide the current state of a RefBigInt by a BigInt.
+ * @remarks
+ * ## Why
+ *
+ * Divide the current state of a RefBigInt by a BigInt. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The divide view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const divide: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint | undefined, E, R>;
@@ -71,8 +137,19 @@ export declare const divide: {
 };
 /**
  * Get the remainder of dividing the current state of a RefBigInt by a BigInt.
+ * @remarks
+ * ## Why
+ *
+ * Get the remainder of dividing the current state of a RefBigInt by a BigInt. The operation
+ * remains attached to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The mod view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const mod: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
@@ -80,38 +157,104 @@ export declare const mod: {
 };
 /**
  * Get the absolute value of the current state of a RefBigInt.
+ * @remarks
+ * ## Why
+ *
+ * Get the absolute value of the current state of a RefBigInt. The operation remains attached to
+ * the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The abs view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const abs: <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
 /**
  * Negate the current state of a RefBigInt.
+ * @remarks
+ * ## Why
+ *
+ * Negate the current state of a RefBigInt. The operation remains attached to the RefSubject's
+ * versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The negate view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const negate: <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
 /**
  * Check if the current state of a RefBigInt is zero.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigInt is zero. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is zero view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export declare const isZero: <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
 /**
  * Check if the current state of a RefBigInt is negative.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigInt is negative. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is negative view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export declare const isNegative: <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
 /**
  * Check if the current state of a RefBigInt is positive.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigInt is positive. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is positive view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export declare const isPositive: <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
 /**
  * Check if the current state of a RefBigInt is less than a BigInt.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigInt is less than a BigInt. The operation remains attached
+ * to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is less than view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export declare const isLessThan: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
@@ -119,8 +262,19 @@ export declare const isLessThan: {
 };
 /**
  * Check if the current state of a RefBigInt is greater than a BigInt.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigInt is greater than a BigInt. The operation remains
+ * attached to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is greater than view retains no independent state. An Effect read samples the source once;
+ * Fx observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category State predicates
  */
 export declare const isGreaterThan: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
@@ -128,8 +282,19 @@ export declare const isGreaterThan: {
 };
 /**
  * Check if the current state of a RefBigInt equals a BigInt.
+ * @remarks
+ * ## Why
+ *
+ * Check if the current state of a RefBigInt equals a BigInt. The operation remains attached to the
+ * RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The equals view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
  * @since 1.18.0
- * @category computed
+ * @category Arithmetic queries
  */
 export declare const equals: {
     (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;