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

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

@@ -2,46 +2,478 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Equivalence-0bc84518.cjs.prod.js');
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-require('../../dist/Either-d03d5f05.cjs.prod.js');
-require('../../dist/Predicate-daa86e61.cjs.prod.js');
-require('../../dist/Utils-864e1d48.cjs.prod.js');
-var Either_dist_effectEither = require('../../dist/Either-3fab3796.cjs.prod.js');
-require('../../dist/Equal-ce9977a8.cjs.prod.js');
-require('../../dist/Hash-1bd73210.cjs.prod.js');
-require('../../dist/GlobalValue-cb645c99.cjs.prod.js');
-require('../../dist/Inspectable-3c4a0f5d.cjs.prod.js');
-require('../../dist/Effectable-f867d1cb.cjs.prod.js');
-require('../../dist/Data-07dc27f1.cjs.prod.js');
-require('../../dist/Pipeable-d3ec6711.cjs.prod.js');
-
-
-
-exports.TypeId = Either_dist_effectEither.TypeId;
-exports.all = Either_dist_effectEither.all;
-exports.flatMap = Either_dist_effectEither.flatMap;
-exports.fromNullable = Either_dist_effectEither.fromNullable;
-exports.fromOption = Either_dist_effectEither.fromOption;
-exports.gen = Either_dist_effectEither.gen;
-exports.getEquivalence = Either_dist_effectEither.getEquivalence;
-exports.getLeft = Either_dist_effectEither.getLeft;
-exports.getOrElse = Either_dist_effectEither.getOrElse;
-exports.getOrNull = Either_dist_effectEither.getOrNull;
-exports.getOrThrow = Either_dist_effectEither.getOrThrow;
-exports.getOrThrowWith = Either_dist_effectEither.getOrThrowWith;
-exports.getOrUndefined = Either_dist_effectEither.getOrUndefined;
-exports.getRight = Either_dist_effectEither.getRight;
-exports.isEither = Either_dist_effectEither.isEither;
-exports.isLeft = Either_dist_effectEither.isLeft;
-exports.isRight = Either_dist_effectEither.isRight;
-exports.left = Either_dist_effectEither.left;
-exports.map = Either_dist_effectEither.map;
-exports.mapBoth = Either_dist_effectEither.mapBoth;
-exports.mapLeft = Either_dist_effectEither.mapLeft;
-exports.match = Either_dist_effectEither.match;
-exports.merge = Either_dist_effectEither.merge;
-exports.orElse = Either_dist_effectEither.orElse;
-exports.reverse = Either_dist_effectEither.reverse;
-exports.right = Either_dist_effectEither.right;
-exports["try"] = Either_dist_effectEither.try_;
+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 Either = require('../../dist/Either-7a881c7a.cjs.prod.js');
+var Predicate_dist_effectPredicate = require('../../Predicate/dist/effect-Predicate.cjs.prod.js');
+var Utils_dist_effectUtils = require('../../Utils/dist/effect-Utils.cjs.prod.js');
+require('../../Equal/dist/effect-Equal.cjs.prod.js');
+require('../../Hash/dist/effect-Hash.cjs.prod.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.prod.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.prod.js');
+require('../../dist/Effectable-cd8f3a96.cjs.prod.js');
+require('../../Data/dist/effect-Data.cjs.prod.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.prod.js');
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category symbols
+ * @since 2.0.0
+ */
+const TypeId = Either.TypeId;
+
+/**
+ * @category symbols
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+/**
+ * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias
+ * of this structure.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const right = Either.right;
+
+/**
+ * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this
+ * structure.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const left = Either.left;
+
+/**
+ * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use
+ * the provided default as a `Left`.
+ *
+ * @example
+ * import * as Either from 'effect/Either'
+ *
+ * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1))
+ * assert.deepStrictEqual(Either.fromNullable(null, () => 'fallback'), Either.left('fallback'))
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const fromNullable = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, onNullable) => self == null ? left(onNullable(self)) : right(self));
+
+/**
+ * @example
+ * import * as Either from 'effect/Either'
+ * import * as Option from 'effect/Option'
+ *
+ * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1))
+ * assert.deepStrictEqual(Either.fromOption(Option.none(), () => 'error'), Either.left('error'))
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const fromOption = Either.fromOption;
+const try_ = evaluate => {
+  if (Predicate_dist_effectPredicate.isFunction(evaluate)) {
+    try {
+      return right(evaluate());
+    } catch (e) {
+      return left(e);
+    }
+  } else {
+    try {
+      return right(evaluate.try());
+    } catch (e) {
+      return left(evaluate.catch(e));
+    }
+  }
+};
+
+/**
+ * Tests if a value is a `Either`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isEither, left, right } from 'effect/Either'
+ *
+ * assert.deepStrictEqual(isEither(right(1)), true)
+ * assert.deepStrictEqual(isEither(left("a")), true)
+ * assert.deepStrictEqual(isEither({ right: 1 }), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isEither = Either.isEither;
+
+/**
+ * Determine if a `Either` is a `Left`.
+ *
+ * @param self - The `Either` to check.
+ *
+ * @example
+ * import { isLeft, left, right } from 'effect/Either'
+ *
+ * assert.deepStrictEqual(isLeft(right(1)), false)
+ * assert.deepStrictEqual(isLeft(left("a")), true)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isLeft = Either.isLeft;
+
+/**
+ * Determine if a `Either` is a `Right`.
+ *
+ * @param self - The `Either` to check.
+ *
+ * @example
+ * import { isRight, left, right } from 'effect/Either'
+ *
+ * assert.deepStrictEqual(isRight(right(1)), true)
+ * assert.deepStrictEqual(isRight(left("a")), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isRight = Either.isRight;
+
+/**
+ * Converts a `Either` to an `Option` discarding the `Left`.
+ *
+ * Alias of {@link toOption}.
+ *
+ * @example
+ * import * as O from 'effect/Option'
+ * import * as E from 'effect/Either'
+ *
+ * assert.deepStrictEqual(E.getRight(E.right('ok')), O.some('ok'))
+ * assert.deepStrictEqual(E.getRight(E.left('err')), O.none())
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getRight = Either.getRight;
+
+/**
+ * Converts a `Either` to an `Option` discarding the value.
+ *
+ * @example
+ * import * as O from 'effect/Option'
+ * import * as E from 'effect/Either'
+ *
+ * assert.deepStrictEqual(E.getLeft(E.right('ok')), O.none())
+ * assert.deepStrictEqual(E.getLeft(E.left('err')), O.some('err'))
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getLeft = Either.getLeft;
+
+/**
+ * @category equivalence
+ * @since 2.0.0
+ */
+const getEquivalence = (EE, EA) => Equivalence_dist_effectEquivalence.make((x, y) => x === y || (isLeft(x) ? isLeft(y) && EE(x.left, y.left) : isRight(y) && EA(x.right, y.right)));
+
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+const mapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  onLeft,
+  onRight
+}) => isLeft(self) ? left(onLeft(self.left)) : right(onRight(self.right)));
+
+/**
+ * Maps the `Left` side of an `Either` value to a new `Either` value.
+ *
+ * @param self - The input `Either` value to map.
+ * @param f - A transformation function to apply to the `Left` value of the input `Either`.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+const mapLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => isLeft(self) ? left(f(self.left)) : right(self.right));
+
+/**
+ * Maps the `Right` side of an `Either` value to a new `Either` value.
+ *
+ * @param self - An `Either` to map
+ * @param f - The function to map over the value of the `Either`
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => isRight(self) ? right(f(self.right)) : left(self.left));
+
+/**
+ * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function,
+ * if the value is a `Right` the inner value is applied to the `onRight` function.
+ *
+ * @example
+ * import * as E from 'effect/Either'
+ * import { pipe } from 'effect/Function'
+ *
+ * const onLeft  = (strings: ReadonlyArray<string>): string => `strings: ${strings.join(', ')}`
+ *
+ * const onRight = (value: number): string => `Ok: ${value}`
+ *
+ * assert.deepStrictEqual(pipe(E.right(1), E.match({ onLeft, onRight })), 'Ok: 1')
+ * assert.deepStrictEqual(
+ *   pipe(E.left(['string 1', 'string 2']), E.match({ onLeft, onRight })),
+ *   'strings: string 1, string 2'
+ * )
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+const match = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  onLeft,
+  onRight
+}) => isLeft(self) ? onLeft(self.left) : onRight(self.right));
+
+/**
+ * @category getters
+ * @since 2.0.0
+ */
+const merge = /*#__PURE__*/match({
+  onLeft: Function_dist_effectFunction.identity,
+  onRight: Function_dist_effectFunction.identity
+});
+
+/**
+ * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.
+ *
+ * @example
+ * import * as Either from 'effect/Either'
+ *
+ * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
+ * assert.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!")
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, onLeft) => isLeft(self) ? onLeft(self.left) : self.right);
+
+/**
+ * @example
+ * import * as Either from 'effect/Either'
+ *
+ * assert.deepStrictEqual(Either.getOrNull(Either.right(1)), 1)
+ * assert.deepStrictEqual(Either.getOrNull(Either.left("a")), null)
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrNull = /*#__PURE__*/getOrElse(Function_dist_effectFunction.constNull);
+
+/**
+ * @example
+ * import * as Either from 'effect/Either'
+ *
+ * assert.deepStrictEqual(Either.getOrUndefined(Either.right(1)), 1)
+ * assert.deepStrictEqual(Either.getOrUndefined(Either.left("a")), undefined)
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrUndefined = /*#__PURE__*/getOrElse(Function_dist_effectFunction.constUndefined);
+
+/**
+ * Extracts the value of an `Either` or throws if the `Either` is `Left`.
+ *
+ * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
+ *
+ * @param self - The `Either` to extract the value from.
+ * @param onLeft - A function that will be called if the `Either` is `Left`. It returns the error to be thrown.
+ *
+ * @example
+ * import * as E from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   E.getOrThrowWith(E.right(1), () => new Error('Unexpected Left')),
+ *   1
+ * )
+ * assert.throws(() => E.getOrThrowWith(E.left("error"), () => new Error('Unexpected Left')))
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrThrowWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, onLeft) => {
+  if (isRight(self)) {
+    return self.right;
+  }
+  throw onLeft(self.left);
+});
+
+/**
+ * Extracts the value of an `Either` or throws if the `Either` is `Left`.
+ *
+ * The thrown error is a default error. To configure the error thrown, see  {@link getOrThrowWith}.
+ *
+ * @param self - The `Either` to extract the value from.
+ * @throws `Error("getOrThrow called on a Left")`
+ *
+ * @example
+ * import * as E from "effect/Either"
+ *
+ * assert.deepStrictEqual(E.getOrThrow(E.right(1)), 1)
+ * assert.throws(() => E.getOrThrow(E.left("error")))
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrThrow = /*#__PURE__*/getOrThrowWith(() => new Error("getOrThrow called on a Left"));
+
+/**
+ * Returns `self` if it is a `Right` or `that` otherwise.
+ *
+ * @param self - The input `Either` value to check and potentially return.
+ * @param that - A function that takes the error value from `self` (if it's a `Left`) and returns a new `Either` value.
+ *
+ * @category error handling
+ * @since 2.0.0
+ */
+const orElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => isLeft(self) ? that(self.left) : right(self.right));
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => isLeft(self) ? left(self.left) : f(self.right));
+
+/**
+ * Takes a structure of `Option`s and returns an `Option` of values with the same structure.
+ *
+ * - If a tuple is supplied, then the returned `Option` will contain a tuple with the same length.
+ * - If a struct is supplied, then the returned `Option` will contain a struct with the same keys.
+ * - If an iterable is supplied, then the returned `Option` will contain an array.
+ *
+ * @param fields - the struct of `Option`s to be sequenced.
+ *
+ * @example
+ * import * as Either from "effect/Either"
+ *
+ * assert.deepStrictEqual(Either.all([Either.right(1), Either.right(2)]), Either.right([1, 2]))
+ * assert.deepStrictEqual(Either.all({ a: Either.right(1), b: Either.right("hello") }), Either.right({ a: 1, b: "hello" }))
+ * assert.deepStrictEqual(Either.all({ a: Either.right(1), b: Either.left("error") }), Either.left("error"))
+ *
+ * @category combining
+ * @since 2.0.0
+ */
+// @ts-expect-error
+const all = input => {
+  if (Symbol.iterator in input) {
+    const out = [];
+    for (const e of input) {
+      if (isLeft(e)) {
+        return e;
+      }
+      out.push(e.right);
+    }
+    return right(out);
+  }
+  const out = {};
+  for (const key of Object.keys(input)) {
+    const e = input[key];
+    if (isLeft(e)) {
+      return e;
+    }
+    out[key] = e.right;
+  }
+  return right(out);
+};
+
+/**
+ * @since 2.0.0
+ */
+const reverse = self => isLeft(self) ? right(self.left) : left(self.right);
+const adapter = /*#__PURE__*/Utils_dist_effectUtils.adapter();
+
+/**
+ * @category generators
+ * @since 2.0.0
+ */
+const gen = f => {
+  const iterator = f(adapter);
+  let state = iterator.next();
+  if (state.done) {
+    return right(void 0);
+  } else {
+    let current = state.value.value;
+    if (isLeft(current)) {
+      return current;
+    }
+    while (!state.done) {
+      state = iterator.next(current.right);
+      if (!state.done) {
+        current = state.value.value;
+        if (isLeft(current)) {
+          return current;
+        }
+      }
+    }
+    return right(state.value);
+  }
+};
+
+exports.TypeId = TypeId;
+exports.all = all;
+exports.flatMap = flatMap;
+exports.fromNullable = fromNullable;
+exports.fromOption = fromOption;
+exports.gen = gen;
+exports.getEquivalence = getEquivalence;
+exports.getLeft = getLeft;
+exports.getOrElse = getOrElse;
+exports.getOrNull = getOrNull;
+exports.getOrThrow = getOrThrow;
+exports.getOrThrowWith = getOrThrowWith;
+exports.getOrUndefined = getOrUndefined;
+exports.getRight = getRight;
+exports.isEither = isEither;
+exports.isLeft = isLeft;
+exports.isRight = isRight;
+exports.left = left;
+exports.map = map;
+exports.mapBoth = mapBoth;
+exports.mapLeft = mapLeft;
+exports.match = match;
+exports.merge = merge;
+exports.orElse = orElse;
+exports.reverse = reverse;
+exports.right = right;
+exports["try"] = try_;