effect 2.0.0-next.42 → 2.0.0-next.43

package/Boolean/dist/effect-Boolean.cjs.prod.js

@@ -2,25 +2,246 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Equivalence-0bc84518.cjs.prod.js');
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-require('../../dist/Order-8a112bfb.cjs.prod.js');
-require('../../dist/Predicate-daa86e61.cjs.prod.js');
-var Boolean_dist_effectBoolean = require('../../dist/Boolean-97839b78.cjs.prod.js');
-
-
-
-exports.Equivalence = Boolean_dist_effectBoolean.Equivalence;
-exports.Order = Boolean_dist_effectBoolean.Order;
-exports.and = Boolean_dist_effectBoolean.and;
-exports.eqv = Boolean_dist_effectBoolean.eqv;
-exports.every = Boolean_dist_effectBoolean.every;
-exports.implies = Boolean_dist_effectBoolean.implies;
-exports.isBoolean = Boolean_dist_effectBoolean.isBoolean;
-exports.match = Boolean_dist_effectBoolean.match;
-exports.nand = Boolean_dist_effectBoolean.nand;
-exports.nor = Boolean_dist_effectBoolean.nor;
-exports.not = Boolean_dist_effectBoolean.not;
-exports.or = Boolean_dist_effectBoolean.or;
-exports.some = Boolean_dist_effectBoolean.some;
-exports.xor = Boolean_dist_effectBoolean.xor;
+var Equivalence_dist_effectEquivalence = require('../../Equivalence/dist/effect-Equivalence.cjs.prod.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.prod.js');
+var Order_dist_effectOrder = require('../../Order/dist/effect-Order.cjs.prod.js');
+var Predicate_dist_effectPredicate = require('../../Predicate/dist/effect-Predicate.cjs.prod.js');
+
+/**
+ * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
+ * It includes functions for basic boolean operations, as well as type class instances for
+ * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * Tests if a value is a `boolean`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isBoolean } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(isBoolean(true), true)
+ * assert.deepStrictEqual(isBoolean("true"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isBoolean = Predicate_dist_effectPredicate.isBoolean;
+
+/**
+ * This function returns the result of either of the given functions depending on the value of the boolean parameter.
+ * It is useful when you have to run one of two functions depending on the boolean value.
+ *
+ * @param value - the boolean value that decides which function will be executed.
+ * @param onFalse - a lazy evaluation function that will be executed when the `value` is `false`.
+ * @param onTrue - a lazy evaluation function that will be executed when the `value` is `true`.
+ *
+ * @example
+ * import * as B from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(B.match(true, { onFalse: () => "It's false!", onTrue: () => "It's true!" }), "It's true!")
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+const match = /*#__PURE__*/Function_dist_effectFunction.dual(2, (value, options) => value ? options.onTrue() : options.onFalse());
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Equivalence = Equivalence_dist_effectEquivalence.boolean;
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Order = Order_dist_effectOrder.boolean;
+
+/**
+ * Negates the given boolean: `!self`
+ *
+ * @example
+ * import { not } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(not(true), false)
+ * assert.deepStrictEqual(not(false), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const not = self => !self;
+
+/**
+ * Combines two boolean using AND: `self && that`.
+ *
+ * @example
+ * import { and } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(and(true, true), true)
+ * assert.deepStrictEqual(and(true, false), false)
+ * assert.deepStrictEqual(and(false, true), false)
+ * assert.deepStrictEqual(and(false, false), false)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const and = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => self && that);
+
+/**
+ * Combines two boolean using NAND: `!(self && that)`.
+ *
+ * @example
+ * import { nand } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(nand(true, true), false)
+ * assert.deepStrictEqual(nand(true, false), true)
+ * assert.deepStrictEqual(nand(false, true), true)
+ * assert.deepStrictEqual(nand(false, false), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const nand = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => !(self && that));
+
+/**
+ * Combines two boolean using OR: `self || that`.
+ *
+ * @example
+ * import { or } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(or(true, true), true)
+ * assert.deepStrictEqual(or(true, false), true)
+ * assert.deepStrictEqual(or(false, true), true)
+ * assert.deepStrictEqual(or(false, false), false)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const or = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => self || that);
+
+/**
+ * Combines two booleans using NOR: `!(self || that)`.
+ *
+ * @example
+ * import { nor } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(nor(true, true), false)
+ * assert.deepStrictEqual(nor(true, false), false)
+ * assert.deepStrictEqual(nor(false, true), false)
+ * assert.deepStrictEqual(nor(false, false), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const nor = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => !(self || that));
+
+/**
+ * Combines two booleans using XOR: `(!self && that) || (self && !that)`.
+ *
+ * @example
+ * import { xor } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(xor(true, true), false)
+ * assert.deepStrictEqual(xor(true, false), true)
+ * assert.deepStrictEqual(xor(false, true), true)
+ * assert.deepStrictEqual(xor(false, false), false)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const xor = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => !self && that || self && !that);
+
+/**
+ * Combines two booleans using EQV (aka XNOR): `!xor(self, that)`.
+ *
+ * @example
+ * import { eqv } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(eqv(true, true), true)
+ * assert.deepStrictEqual(eqv(true, false), false)
+ * assert.deepStrictEqual(eqv(false, true), false)
+ * assert.deepStrictEqual(eqv(false, false), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const eqv = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => !xor(self, that));
+
+/**
+ * Combines two booleans using an implication: `(!self || that)`.
+ *
+ * @example
+ * import { implies } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(implies(true, true), true)
+ * assert.deepStrictEqual(implies(true, false), false)
+ * assert.deepStrictEqual(implies(false, true), true)
+ * assert.deepStrictEqual(implies(false, false), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const implies = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => self ? that : true);
+
+/**
+ * This utility function is used to check if all the elements in a collection of boolean values are `true`.
+ *
+ * @param collection - An iterable collection of booleans.
+ *
+ * @example
+ * import { every } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(every([true, true, true]), true)
+ * assert.deepStrictEqual(every([true, false, true]), false)
+ *
+ * @since 2.0.0
+ */
+const every = collection => {
+  for (const b of collection) {
+    if (!b) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * This utility function is used to check if at least one of the elements in a collection of boolean values is `true`.
+ *
+ * @param collection - An iterable collection of booleans.
+ *
+ * @example
+ * import { some } from 'effect/Boolean'
+ *
+ * assert.deepStrictEqual(some([true, false, true]), true)
+ * assert.deepStrictEqual(some([false, false, false]), false)
+ *
+ * @since 2.0.0
+ */
+const some = collection => {
+  for (const b of collection) {
+    if (b) {
+      return true;
+    }
+  }
+  return false;
+};
+
+exports.Equivalence = Equivalence;
+exports.Order = Order;
+exports.and = and;
+exports.eqv = eqv;
+exports.every = every;
+exports.implies = implies;
+exports.isBoolean = isBoolean;
+exports.match = match;
+exports.nand = nand;
+exports.nor = nor;
+exports.not = not;
+exports.or = or;
+exports.some = some;
+exports.xor = xor;

package/Brand/dist/effect-Brand.cjs.dev.js

@@ -2,33 +2,228 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Either-a806809d.cjs.dev.js');
-require('../../dist/Function-41ce433d.cjs.dev.js');
-require('../../dist/Option-03997d77.cjs.dev.js');
-require('../../dist/ReadonlyArray-48949ee7.cjs.dev.js');
-var Brand_dist_effectBrand = require('../../dist/Brand-b238487d.cjs.dev.js');
-require('../../dist/Equivalence-de7a0d51.cjs.dev.js');
-require('../../dist/Either-9c349424.cjs.dev.js');
-require('../../dist/Equal-281b6ca8.cjs.dev.js');
-require('../../dist/Hash-bd154268.cjs.dev.js');
-require('../../dist/GlobalValue-81ab6908.cjs.dev.js');
-require('../../dist/Utils-b0c14d1b.cjs.dev.js');
-require('../../dist/Predicate-9e859c9c.cjs.dev.js');
-require('../../dist/Inspectable-ac929af4.cjs.dev.js');
-require('../../dist/Effectable-a6403e5f.cjs.dev.js');
-require('../../dist/Data-85559fb3.cjs.dev.js');
-require('../../dist/Pipeable-4698db72.cjs.dev.js');
-require('../../dist/Number-588f6483.cjs.dev.js');
-require('../../dist/Order-28bdebd2.cjs.dev.js');
+var Either_dist_effectEither = require('../../Either/dist/effect-Either.cjs.dev.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.dev.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.dev.js');
+var ReadonlyArray_dist_effectReadonlyArray = require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+require('../../dist/Either-12bbe00c.cjs.dev.js');
+require('../../Equal/dist/effect-Equal.cjs.dev.js');
+require('../../Hash/dist/effect-Hash.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+require('../../dist/Effectable-2f022879.cjs.dev.js');
+require('../../Data/dist/effect-Data.cjs.dev.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+require('../../Order/dist/effect-Order.cjs.dev.js');
 require('../../dist/ReadonlyArray-9a1474f6.cjs.dev.js');
-require('../../dist/ReadonlyRecord-605a625b.cjs.dev.js');
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js');
 
+/**
+ * This module provides types and utility functions to create and work with branded types,
+ * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
+ *
+ * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
+ * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
+ *
+ * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
+ * This is useful when you want to distinguish between two values of the same type that have different meanings.
+ * The `nominal` function does not perform any validation of the input data.
+ *
+ * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
+ * but with a different name, and it also allows for validation of the input data.
+ * The `refined` function takes a predicate that is used to validate the input data.
+ * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
+ *
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const BrandTypeId = /*#__PURE__*/Symbol.for("effect/Brand");
 
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
 
-exports.BrandTypeId = Brand_dist_effectBrand.BrandTypeId;
-exports.RefinedConstructorsTypeId = Brand_dist_effectBrand.RefinedConstructorsTypeId;
-exports.all = Brand_dist_effectBrand.all;
-exports.error = Brand_dist_effectBrand.error;
-exports.errors = Brand_dist_effectBrand.errors;
-exports.nominal = Brand_dist_effectBrand.nominal;
-exports.refined = Brand_dist_effectBrand.refined;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const RefinedConstructorsTypeId = /*#__PURE__*/Symbol.for("effect/Brand/Refined");
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A generic interface that defines a branded type.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category alias
+ * @since 2.0.0
+ */
+
+/**
+ * Returns a `BrandErrors` that contains a single `RefinementError`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const error = (message, meta) => [{
+  message,
+  meta
+}];
+
+/**
+ * Takes a variable number of `BrandErrors` and returns a single `BrandErrors` that contains all refinement errors.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const errors = (...errors) => ReadonlyArray_dist_effectReadonlyArray.flatten(errors);
+
+/**
+ * Returns a `Brand.Constructor` that can construct a branded type from an unbranded value using the provided `refinement`
+ * predicate as validation of the input data.
+ *
+ * If you don't want to perform any validation but only distinguish between two values of the same type but with different meanings,
+ * see {@link nominal}.
+ *
+ * @param refinement - The refinement predicate to apply to the unbranded value.
+ * @param onFailure - Takes the unbranded value that did not pass the `refinement` predicate and returns a `BrandErrors`.
+ *
+ * @example
+ * import * as Brand from "effect/Brand"
+ *
+ * type Int = number & Brand.Brand<"Int">
+ *
+ * const Int = Brand.refined<Int>(
+ *   (n) => Number.isInteger(n),
+ *   (n) => Brand.error(`Expected ${n} to be an integer`)
+ * )
+ *
+ * assert.strictEqual(Int(1), 1)
+ * assert.throws(() => Int(1.1))
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const refined = (refinement, onFailure) => {
+  const either = args => refinement(args) ? Either_dist_effectEither.right(args) : Either_dist_effectEither.left(onFailure(args));
+  // @ts-expect-error
+  return Object.assign(args => Either_dist_effectEither.match(either(args), {
+    onLeft: e => {
+      throw e;
+    },
+    onRight: Function_dist_effectFunction.identity
+  }), {
+    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
+    option: args => Option_dist_effectOption.getRight(either(args)),
+    either,
+    is: args => Either_dist_effectEither.isRight(either(args))
+  });
+};
+
+/**
+ * This function returns a `Brand.Constructor` that **does not apply any runtime checks**, it just returns the provided value.
+ * It can be used to create nominal types that allow distinguishing between two values of the same type but with different meanings.
+ *
+ * If you also want to perform some validation, see {@link refined}.
+ *
+ * @example
+ * import * as Brand from "effect/Brand"
+ *
+ * type UserId = number & Brand.Brand<"UserId">
+ *
+ * const UserId = Brand.nominal<UserId>()
+ *
+ * assert.strictEqual(UserId(1), 1)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const nominal = () => {
+  // @ts-expect-error
+  return Object.assign(args => args, {
+    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
+    option: args => Option_dist_effectOption.some(args),
+    either: args => Either_dist_effectEither.right(args),
+    is: _args => true
+  });
+};
+
+/**
+ * Combines two or more brands together to form a single branded type.
+ * This API is useful when you want to validate that the input data passes multiple brand validators.
+ *
+ * @example
+ * import * as Brand from "effect/Brand"
+ *
+ * type Int = number & Brand.Brand<"Int">
+ * const Int = Brand.refined<Int>(
+ *   (n) => Number.isInteger(n),
+ *   (n) => Brand.error(`Expected ${n} to be an integer`)
+ * )
+ * type Positive = number & Brand.Brand<"Positive">
+ * const Positive = Brand.refined<Positive>(
+ *   (n) => n > 0,
+ *   (n) => Brand.error(`Expected ${n} to be positive`)
+ * )
+ *
+ * const PositiveInt = Brand.all(Int, Positive)
+ *
+ * assert.strictEqual(PositiveInt(1), 1)
+ * assert.throws(() => PositiveInt(1.1))
+ *
+ * @since 2.0.0
+ * @category combining
+ */
+const all = (...brands) => {
+  const either = args => {
+    let result = Either_dist_effectEither.right(args);
+    for (const brand of brands) {
+      const nextResult = brand.either(args);
+      if (Either_dist_effectEither.isLeft(result) && Either_dist_effectEither.isLeft(nextResult)) {
+        result = Either_dist_effectEither.left([...result.left, ...nextResult.left]);
+      } else {
+        result = Either_dist_effectEither.isLeft(result) ? result : nextResult;
+      }
+    }
+    return result;
+  };
+  // @ts-expect-error
+  return Object.assign(args => Either_dist_effectEither.match(either(args), {
+    onLeft: e => {
+      throw e;
+    },
+    onRight: Function_dist_effectFunction.identity
+  }), {
+    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
+    option: args => Option_dist_effectOption.getRight(either(args)),
+    either,
+    is: args => Either_dist_effectEither.isRight(either(args))
+  });
+};
+
+exports.BrandTypeId = BrandTypeId;
+exports.RefinedConstructorsTypeId = RefinedConstructorsTypeId;
+exports.all = all;
+exports.error = error;
+exports.errors = errors;
+exports.nominal = nominal;
+exports.refined = refined;