effect 4.0.0-beta.4 → 4.0.0-beta.41

package/dist/MutableHashSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MutableHashSet.d.ts","sourceRoot":"","sources":["../src/MutableHashSet.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"MutableHashSet.d.ts","sourceRoot":"","sources":["../src/MutableHashSet.ts"],"names":[],"mappings":"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"}

package/dist/MutableHashSet.js

@@ -29,7 +29,15 @@ import * as Dual from "./Function.js";
 import { NodeInspectSymbol, toJson } from "./Inspectable.js";
 import * as MutableHashMap from "./MutableHashMap.js";
 import { pipeArguments } from "./Pipeable.js";
+import { hasProperty } from "./Predicate.js";
 const TypeId = "~effect/collections/MutableHashSet";
+/**
+ * Checks if the specified value is a `MutableHashSet`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashSet = value => hasProperty(value, TypeId);
 const MutableHashSetProto = {
   [TypeId]: TypeId,
   [Symbol.iterator]() {

package/dist/MutableHashSet.js.map

@@ -1 +1 @@
-{"version":3,"file":"MutableHashSet.js","names":["format","Dual","NodeInspectSymbol","toJson","MutableHashMap","pipeArguments","TypeId","MutableHashSetProto","Symbol","iterator","Array","from","keyMap","map","_","toString","toJSON","_id","values","pipe","arguments","fromHashMap","set","Object","create","empty","fromIterable","keys","k","make","add","dual","self","key","has","remove","size","clear"],"sources":["../src/MutableHashSet.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"MutableHashSet.js","names":["format","Dual","NodeInspectSymbol","toJson","MutableHashMap","pipeArguments","hasProperty","TypeId","isMutableHashSet","value","MutableHashSetProto","Symbol","iterator","Array","from","keyMap","map","_","toString","toJSON","_id","values","pipe","arguments","fromHashMap","set","Object","create","empty","fromIterable","keys","k","make","add","dual","self","key","has","remove","size","clear"],"sources":["../src/MutableHashSet.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/Newtype.d.ts

@@ -0,0 +1,291 @@
+/**
+ * Lightweight wrapper types that prevent accidental mixing of structurally
+ * identical values (e.g. `UserId` vs `OrderId`, both `string` at runtime).
+ *
+ * **Mental model**
+ *
+ * - **Newtype** — a compile-time wrapper around a **carrier** type (the
+ *   underlying primitive or object). At runtime the value is unchanged; the
+ *   tag exists only in the type system.
+ * - **Key** — a unique string literal that distinguishes one newtype from
+ *   another (e.g. `"Label"`, `"UserId"`).
+ * - **Carrier** — the underlying type the newtype wraps (e.g. `string`,
+ *   `number`).
+ * - **Iso** — a lossless two-way conversion between a newtype and its carrier,
+ *   created with {@link makeIso}. Use `iso.set(carrier)` to wrap and
+ *   `iso.get(newtype)` to unwrap.
+ *
+ * **Common tasks**
+ *
+ * - Define a newtype → declare an `interface` extending
+ *   `Newtype.Newtype<Key, Carrier>`
+ * - Wrap / unwrap values → {@link makeIso} (returns an `Optic.Iso`)
+ * - Unwrap only → {@link value}
+ * - Lift an `Equivalence` → {@link makeEquivalence}
+ * - Lift an `Order` → {@link makeOrder}
+ * - Lift a `Combiner` → {@link makeCombiner}
+ * - Lift a `Reducer` → {@link makeReducer}
+ *
+ * **Gotchas**
+ *
+ * - Newtypes are **purely compile-time**. There is zero runtime overhead;
+ *   `value` and `makeIso` use identity casts.
+ * - Two newtypes sharing the same key string will be assignable to each other.
+ *   Choose unique key strings.
+ * - A newtype value is **not** assignable to its carrier type without
+ *   explicitly unwrapping via {@link value} or an iso.
+ *
+ * **Quickstart**
+ *
+ * **Example** (defining and using a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * // 1. Define a newtype
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * // 2. Create an iso for wrapping/unwrapping
+ * const labelIso = Newtype.makeIso<Label>()
+ *
+ * // 3. Wrap a raw string
+ * const myLabel: Label = labelIso.set("hello")
+ *
+ * // 4. Unwrap back to string
+ * const raw: string = labelIso.get(myLabel) // "hello"
+ * ```
+ *
+ * **See also**
+ *
+ * - {@link Newtype} (the tagged interface)
+ * - {@link makeIso} (wrap and unwrap)
+ * - {@link value} (unwrap only)
+ *
+ * @since 4.0.0
+ */
+import type * as Combiner from "./Combiner.ts";
+import type * as Equivalence from "./Equivalence.ts";
+import * as Optic from "./Optic.ts";
+import type * as Order from "./Order.ts";
+import type * as Reducer from "./Reducer.ts";
+declare const TypeId = "~effect/Newtype";
+/**
+ * A tagged interface that wraps a carrier type under a unique key, preventing
+ * accidental interchange of structurally identical values.
+ *
+ * - Define your newtype as an `interface` extending
+ *   `Newtype<"MyKey", CarrierType>`.
+ * - The tag is compile-time only; no runtime wrapper is allocated.
+ * - Use {@link makeIso} to create a two-way conversion, or {@link value} to
+ *   unwrap.
+ *
+ * **Example** (defining a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface UserId extends Newtype.Newtype<"UserId", number> {}
+ * interface OrderId extends Newtype.Newtype<"OrderId", number> {}
+ *
+ * // UserId and OrderId are not assignable to each other
+ * // even though both wrap `number`.
+ * ```
+ *
+ * @see {@link makeIso} — create an iso to wrap and unwrap
+ * @see {@link value} — unwrap a newtype value
+ *
+ * @since 4.0.0
+ */
+export interface Newtype<in out Key extends string, out Carrier> {
+    readonly [TypeId]: {
+        readonly key: Key;
+        readonly carrier: Carrier;
+    };
+}
+/**
+ * @since 4.0.0
+ */
+export declare namespace Newtype {
+    /**
+     * A type that matches any `Newtype`, useful as a generic constraint:
+     * `<N extends Newtype.Any>`.
+     *
+     * @see {@link Newtype} — the base tagged interface
+     *
+     * @since 4.0.0
+     */
+    type Any = Newtype<any, unknown>;
+    /**
+     * Extracts the key literal type from a newtype.
+     *
+     * - Useful in generic code that needs to inspect or constrain the key.
+     *
+     * @since 4.0.0
+     */
+    type Key<N extends Any> = N extends Newtype<infer Key, unknown> ? Key : never;
+    /**
+     * Extracts the carrier (underlying) type from a newtype.
+     *
+     * - Useful when you need to refer to the wrapped type in generic utilities.
+     *
+     * @since 4.0.0
+     */
+    type Carrier<N extends Any> = N extends Newtype<infer _Key, infer Carrier> ? Carrier : never;
+}
+/**
+ * Unwraps a newtype value, returning the underlying carrier value.
+ *
+ * - Use when you only need to read the inner value and do not need to wrap new
+ *   values.
+ * - For both wrapping and unwrapping, prefer {@link makeIso}.
+ * - Zero runtime cost: this is an identity cast.
+ *
+ * **Example** (unwrapping a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const iso = Newtype.makeIso<Label>()
+ * const label = iso.set("hello")
+ *
+ * const raw: string = Newtype.value(label) // "hello"
+ * ```
+ *
+ * @see {@link makeIso} — two-way conversion (wrap and unwrap)
+ *
+ * @since 4.0.0
+ */
+export declare const value: <N extends Newtype.Any>(newtype: N) => Newtype.Carrier<N>;
+/**
+ * Creates an `Optic.Iso` for a newtype, providing both wrapping (`set`) and
+ * unwrapping (`get`).
+ *
+ * - Use this as the primary way to construct and deconstruct newtype values.
+ * - The returned iso composes with other optics via the standard `Optic` API.
+ * - Zero runtime cost: both directions are identity casts.
+ *
+ * **Example** (wrapping and unwrapping with an iso)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const labelIso = Newtype.makeIso<Label>()
+ *
+ * const label: Label = labelIso.set("world")
+ * const str: string = labelIso.get(label) // "world"
+ * ```
+ *
+ * @see {@link value} — unwrap only
+ *
+ * @since 4.0.0
+ */
+export declare function makeIso<N extends Newtype.Any>(): Optic.Iso<N, Newtype.Carrier<N>>;
+/**
+ * Lifts an `Equivalence` for the carrier type into an `Equivalence` for the
+ * newtype.
+ *
+ * - Use when you need to compare two newtype values for equality.
+ * - The returned equivalence delegates to the provided carrier equivalence.
+ * - Zero runtime cost beyond the underlying equivalence check.
+ *
+ * **Example** (comparing newtypes)
+ *
+ * ```ts
+ * import { Newtype, Equivalence } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const eq = Newtype.makeEquivalence<Label>(Equivalence.String)
+ * const iso = Newtype.makeIso<Label>()
+ *
+ * eq(iso.set("a"), iso.set("a")) // true
+ * eq(iso.set("a"), iso.set("b")) // false
+ * ```
+ *
+ * @see {@link makeOrder} — lift an `Order` for the carrier
+ *
+ * @since 4.0.0
+ */
+export declare const makeEquivalence: <N extends Newtype.Any>(equivalence: Equivalence.Equivalence<Newtype.Carrier<N>>) => Equivalence.Equivalence<N>;
+/**
+ * Lifts an `Order` for the carrier type into an `Order` for the newtype.
+ *
+ * - Use when you need to sort or compare newtype values.
+ * - The returned order delegates to the provided carrier order.
+ *
+ * **Example** (ordering newtypes)
+ *
+ * ```ts
+ * import { Newtype, Order } from "effect"
+ *
+ * interface Score extends Newtype.Newtype<"Score", number> {}
+ *
+ * const ord = Newtype.makeOrder<Score>(Order.Number)
+ * const iso = Newtype.makeIso<Score>()
+ *
+ * ord(iso.set(1), iso.set(2)) // -1
+ * ```
+ *
+ * @see {@link makeEquivalence} — lift an `Equivalence` for the carrier
+ *
+ * @since 4.0.0
+ */
+export declare const makeOrder: <N extends Newtype.Any>(order: Order.Order<Newtype.Carrier<N>>) => Order.Order<N>;
+/**
+ * Lifts a `Combiner` for the carrier type into a `Combiner` for the newtype.
+ *
+ * - Use when you need to combine (e.g. concatenate, add) newtype values.
+ * - The returned combiner delegates to the provided carrier combiner.
+ *
+ * **Example** (combining newtypes)
+ *
+ * ```ts
+ * import { Newtype, Combiner } from "effect"
+ *
+ * interface Amount extends Newtype.Newtype<"Amount", number> {}
+ *
+ * const sum = Combiner.make<number>((a, b) => a + b)
+ * const combiner = Newtype.makeCombiner<Amount>(sum)
+ * const iso = Newtype.makeIso<Amount>()
+ *
+ * const total = combiner.combine(iso.set(10), iso.set(20))
+ * Newtype.value(total) // 30
+ * ```
+ *
+ * @see {@link makeReducer} — lift a `Reducer` for the carrier
+ *
+ * @since 4.0.0
+ */
+export declare const makeCombiner: <N extends Newtype.Any>(combiner: Combiner.Combiner<Newtype.Carrier<N>>) => Combiner.Combiner<N>;
+/**
+ * Lifts a `Reducer` for the carrier type into a `Reducer` for the newtype.
+ *
+ * - Use when you need to fold/reduce over a collection of newtype values.
+ * - The returned reducer delegates to the provided carrier reducer.
+ *
+ * **Example** (reducing newtypes)
+ *
+ * ```ts
+ * import { Newtype, Reducer } from "effect"
+ *
+ * interface Score extends Newtype.Newtype<"Score", number> {}
+ *
+ * const sum = Reducer.make<number>((a, b) => a + b, 0)
+ * const reducer = Newtype.makeReducer<Score>(sum)
+ * const iso = Newtype.makeIso<Score>()
+ *
+ * const total = reducer.combineAll([iso.set(1), iso.set(2), iso.set(3)])
+ * Newtype.value(total) // 6
+ * ```
+ *
+ * @see {@link makeCombiner} — lift a `Combiner` for the carrier
+ *
+ * @since 4.0.0
+ */
+export declare const makeReducer: <N extends Newtype.Any>(reducer: Reducer.Reducer<Newtype.Carrier<N>>) => Reducer.Reducer<N>;
+export {};
+//# sourceMappingURL=Newtype.d.ts.map

package/dist/Newtype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Newtype.d.ts","sourceRoot":"","sources":["../src/Newtype.ts"],"names":[],"mappings":"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"}

package/dist/Newtype.js

@@ -0,0 +1,161 @@
+import { cast } from "./Function.js";
+import * as Optic from "./Optic.js";
+const TypeId = "~effect/Newtype";
+/**
+ * Unwraps a newtype value, returning the underlying carrier value.
+ *
+ * - Use when you only need to read the inner value and do not need to wrap new
+ *   values.
+ * - For both wrapping and unwrapping, prefer {@link makeIso}.
+ * - Zero runtime cost: this is an identity cast.
+ *
+ * **Example** (unwrapping a newtype)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const iso = Newtype.makeIso<Label>()
+ * const label = iso.set("hello")
+ *
+ * const raw: string = Newtype.value(label) // "hello"
+ * ```
+ *
+ * @see {@link makeIso} — two-way conversion (wrap and unwrap)
+ *
+ * @since 4.0.0
+ */
+export const value = cast;
+/**
+ * Creates an `Optic.Iso` for a newtype, providing both wrapping (`set`) and
+ * unwrapping (`get`).
+ *
+ * - Use this as the primary way to construct and deconstruct newtype values.
+ * - The returned iso composes with other optics via the standard `Optic` API.
+ * - Zero runtime cost: both directions are identity casts.
+ *
+ * **Example** (wrapping and unwrapping with an iso)
+ *
+ * ```ts
+ * import { Newtype } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const labelIso = Newtype.makeIso<Label>()
+ *
+ * const label: Label = labelIso.set("world")
+ * const str: string = labelIso.get(label) // "world"
+ * ```
+ *
+ * @see {@link value} — unwrap only
+ *
+ * @since 4.0.0
+ */
+export function makeIso() {
+  return Optic.makeIso(value, cast);
+}
+/**
+ * Lifts an `Equivalence` for the carrier type into an `Equivalence` for the
+ * newtype.
+ *
+ * - Use when you need to compare two newtype values for equality.
+ * - The returned equivalence delegates to the provided carrier equivalence.
+ * - Zero runtime cost beyond the underlying equivalence check.
+ *
+ * **Example** (comparing newtypes)
+ *
+ * ```ts
+ * import { Newtype, Equivalence } from "effect"
+ *
+ * interface Label extends Newtype.Newtype<"Label", string> {}
+ *
+ * const eq = Newtype.makeEquivalence<Label>(Equivalence.String)
+ * const iso = Newtype.makeIso<Label>()
+ *
+ * eq(iso.set("a"), iso.set("a")) // true
+ * eq(iso.set("a"), iso.set("b")) // false
+ * ```
+ *
+ * @see {@link makeOrder} — lift an `Order` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeEquivalence = cast;
+/**
+ * Lifts an `Order` for the carrier type into an `Order` for the newtype.
+ *
+ * - Use when you need to sort or compare newtype values.
+ * - The returned order delegates to the provided carrier order.
+ *
+ * **Example** (ordering newtypes)
+ *
+ * ```ts
+ * import { Newtype, Order } from "effect"
+ *
+ * interface Score extends Newtype.Newtype<"Score", number> {}
+ *
+ * const ord = Newtype.makeOrder<Score>(Order.Number)
+ * const iso = Newtype.makeIso<Score>()
+ *
+ * ord(iso.set(1), iso.set(2)) // -1
+ * ```
+ *
+ * @see {@link makeEquivalence} — lift an `Equivalence` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeOrder = cast;
+/**
+ * Lifts a `Combiner` for the carrier type into a `Combiner` for the newtype.
+ *
+ * - Use when you need to combine (e.g. concatenate, add) newtype values.
+ * - The returned combiner delegates to the provided carrier combiner.
+ *
+ * **Example** (combining newtypes)
+ *
+ * ```ts
+ * import { Newtype, Combiner } from "effect"
+ *
+ * interface Amount extends Newtype.Newtype<"Amount", number> {}
+ *
+ * const sum = Combiner.make<number>((a, b) => a + b)
+ * const combiner = Newtype.makeCombiner<Amount>(sum)
+ * const iso = Newtype.makeIso<Amount>()
+ *
+ * const total = combiner.combine(iso.set(10), iso.set(20))
+ * Newtype.value(total) // 30
+ * ```
+ *
+ * @see {@link makeReducer} — lift a `Reducer` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeCombiner = cast;
+/**
+ * Lifts a `Reducer` for the carrier type into a `Reducer` for the newtype.
+ *
+ * - Use when you need to fold/reduce over a collection of newtype values.
+ * - The returned reducer delegates to the provided carrier reducer.
+ *
+ * **Example** (reducing newtypes)
+ *
+ * ```ts
+ * import { Newtype, Reducer } from "effect"
+ *
+ * interface Score extends Newtype.Newtype<"Score", number> {}
+ *
+ * const sum = Reducer.make<number>((a, b) => a + b, 0)
+ * const reducer = Newtype.makeReducer<Score>(sum)
+ * const iso = Newtype.makeIso<Score>()
+ *
+ * const total = reducer.combineAll([iso.set(1), iso.set(2), iso.set(3)])
+ * Newtype.value(total) // 6
+ * ```
+ *
+ * @see {@link makeCombiner} — lift a `Combiner` for the carrier
+ *
+ * @since 4.0.0
+ */
+export const makeReducer = cast;
+//# sourceMappingURL=Newtype.js.map

package/dist/Newtype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Newtype.js","names":["cast","Optic","TypeId","value","makeIso","makeEquivalence","makeOrder","makeCombiner","makeReducer"],"sources":["../src/Newtype.ts"],"sourcesContent":[null],"mappings":"AAmEA,SAASA,IAAI,QAAQ,eAAe;AACpC,OAAO,KAAKC,KAAK,MAAM,YAAY;AAInC,MAAMC,MAAM,GAAG,iBAAiB;AAqEhC;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,KAAK,GAA8DH,IAAI;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAM,SAAUI,OAAOA,CAAA;EACrB,OAAOH,KAAK,CAACG,OAAO,CAACD,KAAK,EAAEH,IAAI,CAAC;AACnC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMK,eAAe,GAEML,IAAI;AAEtC;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAMM,SAAS,GAAsFN,IAAI;AAEhH;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMO,YAAY,GAEGP,IAAI;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMQ,WAAW,GACtBR,IAAI","ignoreList":[]}

package/dist/Number.d.ts

@@ -5,6 +5,7 @@
  * @since 2.0.0
  */
 import * as Equ from "./Equivalence.ts";
+import * as Option from "./Option.ts";
 import * as order from "./Order.ts";
 import type { Ordering } from "./Ordering.ts";
 import * as Reducer from "./Reducer.ts";
@@ -183,15 +184,15 @@ export declare const subtract: {
 /**
  * Provides a division operation on `number`s.
  *
- * Returns `undefined` if the divisor is `0`.
+ * Returns `Option.none()` if the divisor is `0`.
  *
  * **Example**
  *
  * ```ts
  * import { Number } from "effect"
  *
- * Number.divide(6, 3) // 2
- * Number.divide(6, 0) // undefined
+ * Number.divide(6, 3) // Option.some(2)
+ * Number.divide(6, 0) // Option.none()
  * ```
  *
  * @category math
@@ -201,39 +202,94 @@ export declare const divide: {
     /**
      * Provides a division operation on `number`s.
      *
-     * Returns `undefined` if the divisor is `0`.
+     * Returns `Option.none()` if the divisor is `0`.
      *
      * **Example**
      *
      * ```ts
      * import { Number } from "effect"
      *
-     * Number.divide(6, 3) // 2
-     * Number.divide(6, 0) // undefined
+     * Number.divide(6, 3) // Option.some(2)
+     * Number.divide(6, 0) // Option.none()
      * ```
      *
      * @category math
      * @since 2.0.0
      */
-    (that: number): (self: number) => number | undefined;
+    (that: number): (self: number) => Option.Option<number>;
     /**
      * Provides a division operation on `number`s.
      *
-     * Returns `undefined` if the divisor is `0`.
+     * Returns `Option.none()` if the divisor is `0`.
      *
      * **Example**
      *
      * ```ts
      * import { Number } from "effect"
      *
-     * Number.divide(6, 3) // 2
-     * Number.divide(6, 0) // undefined
+     * Number.divide(6, 3) // Option.some(2)
+     * Number.divide(6, 0) // Option.none()
      * ```
      *
      * @category math
      * @since 2.0.0
      */
-    (self: number, that: number): number | undefined;
+    (self: number, that: number): Option.Option<number>;
+};
+/**
+ * Provides an unsafe division operation on `number`s.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Number } from "effect"
+ *
+ * Number.divideUnsafe(6, 3) // 2
+ * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const divideUnsafe: {
+    /**
+     * Provides an unsafe division operation on `number`s.
+     *
+     * Throws a `RangeError` if the divisor is `0`.
+     *
+     * **Example**
+     *
+     * ```ts
+     * import { Number } from "effect"
+     *
+     * Number.divideUnsafe(6, 3) // 2
+     * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: number): (self: number) => number;
+    /**
+     * Provides an unsafe division operation on `number`s.
+     *
+     * Throws a `RangeError` if the divisor is `0`.
+     *
+     * **Example**
+     *
+     * ```ts
+     * import { Number } from "effect"
+     *
+     * Number.divideUnsafe(6, 3) // 2
+     * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: number, that: number): number;
 };
 /**
  * Returns the result of adding `1` to a given number.
@@ -869,18 +925,18 @@ export declare const nextPow2: (n: number) => number;
  * ```ts
  * import { Number } from "effect"
  *
- * Number.parse("42") // 42
- * Number.parse("3.14") // 3.14
- * Number.parse("NaN") // NaN
- * Number.parse("Infinity") // Infinity
- * Number.parse("-Infinity") // -Infinity
- * Number.parse("not a number") // undefined
+ * Number.parse("42") // Option.some(42)
+ * Number.parse("3.14") // Option.some(3.14)
+ * Number.parse("NaN") // Option.some(NaN)
+ * Number.parse("Infinity") // Option.some(Infinity)
+ * Number.parse("-Infinity") // Option.some(-Infinity)
+ * Number.parse("not a number") // Option.none()
  * ```
  *
  * @category constructors
  * @since 2.0.0
  */
-export declare const parse: (s: string) => number | undefined;
+export declare const parse: (s: string) => Option.Option<number>;
 /**
  * Returns the number rounded with the given precision.
  *