effect 2.0.0-next.38 → 2.0.0-next.39

package/dist/Function-12511160.esm.js

@@ -1,516 +0,0 @@
-/**
- * @since 2.0.0
- */
-
-/**
- * @category type lambdas
- * @since 2.0.0
- */
-
-/**
- * Tests if a value is a `function`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isFunction } from 'effect/Predicate'
- *
- * assert.deepStrictEqual(isFunction(isFunction), true)
- * assert.deepStrictEqual(isFunction("function"), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction = input => typeof input === "function";
-
-/**
- * Creates a function that can be used in a data-last (aka `pipe`able) or
- * data-first style.
- *
- * The first parameter to `dual` is either the arity of the uncurried function
- * or a predicate that determines if the function is being used in a data-first
- * or data-last style.
- *
- * Using the arity is the most common use case, but there are some cases where
- * you may want to use a predicate. For example, if you have a function that
- * takes an optional argument, you can use a predicate to determine if the
- * function is being used in a data-first or data-last style.
- *
- * @param arity - Either the arity of the uncurried function or a predicate
- *                which determines if the function is being used in a data-first
- *                or data-last style.
- * @param body - The definition of the uncurried function.
- *
- * @example
- * import { dual, pipe } from "effect/Function"
- *
- * // Exampe using arity to determine data-first or data-last style
- * export const sum: {
- *   (that: number): (self: number) => number
- *   (self: number, that: number): number
- * } = dual(2, (self: number, that: number): number => self + that)
- *
- * assert.deepStrictEqual(sum(2, 3), 5)
- * assert.deepStrictEqual(pipe(2, sum(3)), 5)
- *
- * // Example using a predicate to determine data-first or data-last style
- * export const sum2: {
- *   (that: number): (self: number) => number
- *   (self: number, that: number): number
- * } = dual((args) => args.length === 1, (self: number, that: number): number => self + that)
- *
- * assert.deepStrictEqual(sum(2, 3), 5)
- * assert.deepStrictEqual(pipe(2, sum(3)), 5)
- *
- * @since 2.0.0
- */
-const dual = function (arity, body) {
-  if (typeof arity === "function") {
-    return function () {
-      if (arity(arguments)) {
-        // @ts-expect-error
-        return body.apply(this, arguments);
-      }
-      return self => body(self, ...arguments);
-    };
-  }
-  switch (arity) {
-    case 0:
-      return body;
-    case 1:
-      return function (a) {
-        if (arguments.length >= 1) {
-          return body(a);
-        }
-        return function () {
-          return body(a);
-        };
-      };
-    case 2:
-      return function (a, b) {
-        if (arguments.length >= 2) {
-          return body(a, b);
-        }
-        return function (self) {
-          return body(self, a);
-        };
-      };
-    case 3:
-      return function (a, b, c) {
-        if (arguments.length >= 3) {
-          return body(a, b, c);
-        }
-        return function (self) {
-          return body(self, a, b);
-        };
-      };
-    case 4:
-      return function (a, b, c, d) {
-        if (arguments.length >= 4) {
-          return body(a, b, c, d);
-        }
-        return function (self) {
-          return body(self, a, b, c);
-        };
-      };
-    case 5:
-      return function (a, b, c, d, e) {
-        if (arguments.length >= 5) {
-          return body(a, b, c, d, e);
-        }
-        return function (self) {
-          return body(self, a, b, c, d);
-        };
-      };
-    default:
-      return function () {
-        if (arguments.length >= arity) {
-          // @ts-expect-error
-          return body.apply(this, arguments);
-        }
-        const args = arguments;
-        return function (self) {
-          return body(self, ...args);
-        };
-      };
-  }
-};
-/**
- * Apply a function to a given value.
- *
- * @param a - The value that the function will be applied to.
- * @param self - The function to be applied to a value.
- *
- * @example
- * import { pipe, apply } from "effect/Function"
- * import { length } from 'effect/String'
- *
- * assert.deepStrictEqual(pipe(length, apply("hello")), 5)
- *
- * @since 2.0.0
- */
-const apply = a => self => self(a);
-
-/**
- * A lazy argument.
- *
- * @example
- * import { LazyArg, constant } from "effect/Function"
- *
- * export const constNull: LazyArg<null> = constant(null)
- *
- * @since 2.0.0
- */
-
-/**
- * @example
- * import { FunctionN } from "effect/Function"
- *
- * export const sum: FunctionN<[number, number], number> = (a, b) => a + b
- *
- * @since 2.0.0
- */
-
-/**
- * The identity function, i.e. A function that returns its input argument.
- *
- * @param a - The input argument.
- *
- * @example
- * import { identity } from "effect/Function"
- *
- * assert.deepStrictEqual(identity(5), 5)
- *
- * @since 2.0.0
- */
-const identity = a => a;
-
-/**
- * Casts the result to the specified type.
- *
- * @param a - The value to be casted to the target type.
- *
- * @example
- * import { unsafeCoerce, identity } from "effect/Function"
- *
- * assert.deepStrictEqual(unsafeCoerce, identity)
- *
- * @since 2.0.0
- */
-const unsafeCoerce = identity;
-
-/**
- * Creates a constant value that never changes.
- *
- * This is useful when you want to pass a value to a higher-order function (a function that takes another function as its argument)
- * and want that inner function to always use the same value, no matter how many times it is called.
- *
- * @param value - The constant value to be returned.
- *
- * @example
- * import { constant } from "effect/Function"
- *
- * const constNull = constant(null)
- *
- * assert.deepStrictEqual(constNull(), null)
- * assert.deepStrictEqual(constNull(), null)
- *
- * @since 2.0.0
- */
-const constant = value => () => value;
-
-/**
- * A thunk that returns always `true`.
- *
- * @example
- * import { constTrue } from "effect/Function"
- *
- * assert.deepStrictEqual(constTrue(), true)
- *
- * @since 2.0.0
- */
-const constTrue = /*#__PURE__*/constant(true);
-
-/**
- * A thunk that returns always `false`.
- *
- * @example
- * import { constFalse } from "effect/Function"
- *
- * assert.deepStrictEqual(constFalse(), false)
- *
- * @since 2.0.0
- */
-const constFalse = /*#__PURE__*/constant(false);
-
-/**
- * A thunk that returns always `null`.
- *
- * @example
- * import { constNull } from "effect/Function"
- *
- * assert.deepStrictEqual(constNull(), null)
- *
- * @since 2.0.0
- */
-const constNull = /*#__PURE__*/constant(null);
-
-/**
- * A thunk that returns always `undefined`.
- *
- * @example
- * import { constUndefined } from "effect/Function"
- *
- * assert.deepStrictEqual(constUndefined(), undefined)
- *
- * @since 2.0.0
- */
-const constUndefined = /*#__PURE__*/constant(undefined);
-
-/**
- * A thunk that returns always `void`.
- *
- * @example
- * import { constVoid } from "effect/Function"
- *
- * assert.deepStrictEqual(constVoid(), undefined)
- *
- * @since 2.0.0
- */
-const constVoid = constUndefined;
-
-/**
- * Reverses the order of arguments for a curried function.
- *
- * @param f - A curried function that takes multiple arguments.
- *
- * @example
- * import { flip } from "effect/Function"
- *
- * const f = (a: number) => (b: string) => a - b.length
- *
- * assert.deepStrictEqual(flip(f)('aaa')(2), -1)
- *
- * @since 2.0.0
- */
-const flip = f => (...b) => (...a) => f(...a)(...b);
-
-/**
- * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
- * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
- *
- * @param ab - A function that maps from `A` to `B`.
- * @param bc - A function that maps from `B` to `C`.
- *
- * @example
- * import { compose } from "effect/Function"
- *
- * const increment = (n: number) => n + 1;
- * const square = (n: number) => n * n;
- *
- * assert.strictEqual(compose(increment, square)(2), 9);
- *
- * @since 2.0.0
- */
-const compose = /*#__PURE__*/dual(2, (ab, bc) => a => bc(ab(a)));
-
-/**
- * The `absurd` function is a stub for cases where a value of type `never` is encountered in your code,
- * meaning that it should be impossible for this code to be executed.
- *
- * This function is particularly when it's necessary to specify that certain cases are impossible.
- *
- * @since 2.0.0
- */
-const absurd = _ => {
-  throw new Error("Called `absurd` function which should be uncallable");
-};
-
-/**
- * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
- *
- * @example
- * import { tupled } from "effect/Function"
- *
- * const sumTupled = tupled((x: number, y: number): number => x + y)
- *
- * assert.deepStrictEqual(sumTupled([1, 2]), 3)
- *
- * @since 2.0.0
- */
-const tupled = f => a => f(...a);
-
-/**
- * Inverse function of `tupled`
- *
- * @example
- * import { untupled } from "effect/Function"
- *
- * const getFirst = untupled(<A, B>(tuple: [A, B]): A => tuple[0])
- *
- * assert.deepStrictEqual(getFirst(1, 2), 1)
- *
- * @since 2.0.0
- */
-const untupled = f => (...a) => f(a);
-
-/**
- * Pipes the value of an expression into a pipeline of functions.
- *
- * This is useful in combination with data-last functions as a simulation of methods:
- *
- * ```
- * as.map(f).filter(g) -> pipe(as, map(f), filter(g))
- * ```
- *
- * @example
- * import { pipe } from "effect/Function"
- *
- * const length = (s: string): number => s.length
- * const double = (n: number): number => n * 2
- * const decrement = (n: number): number => n - 1
- *
- * assert.deepStrictEqual(pipe(length("hello"), double, decrement), 9)
- *
- * @since 2.0.0
- */
-
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
-  switch (arguments.length) {
-    case 1:
-      return a;
-    case 2:
-      return ab(a);
-    case 3:
-      return bc(ab(a));
-    case 4:
-      return cd(bc(ab(a)));
-    case 5:
-      return de(cd(bc(ab(a))));
-    case 6:
-      return ef(de(cd(bc(ab(a)))));
-    case 7:
-      return fg(ef(de(cd(bc(ab(a))))));
-    case 8:
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
-    case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    default:
-      {
-        let ret = arguments[0];
-        for (let i = 1; i < arguments.length; i++) {
-          ret = arguments[i](ret);
-        }
-        return ret;
-      }
-  }
-}
-
-/**
- * Performs left-to-right function composition. The first argument may have any arity, the remaining arguments must be unary.
- *
- * See also [`pipe`](#pipe).
- *
- * @example
- * import { flow } from "effect/Function"
- *
- * const len = (s: string): number => s.length
- * const double = (n: number): number => n * 2
- *
- * const f = flow(len, double)
- *
- * assert.strictEqual(f('aaa'), 6)
- *
- * @since 2.0.0
- */
-
-function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
-  switch (arguments.length) {
-    case 1:
-      return ab;
-    case 2:
-      return function () {
-        return bc(ab.apply(this, arguments));
-      };
-    case 3:
-      return function () {
-        return cd(bc(ab.apply(this, arguments)));
-      };
-    case 4:
-      return function () {
-        return de(cd(bc(ab.apply(this, arguments))));
-      };
-    case 5:
-      return function () {
-        return ef(de(cd(bc(ab.apply(this, arguments)))));
-      };
-    case 6:
-      return function () {
-        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
-      };
-    case 7:
-      return function () {
-        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
-      };
-    case 8:
-      return function () {
-        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
-      };
-    case 9:
-      return function () {
-        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
-      };
-  }
-  return;
-}
-
-/**
- * Type hole simulation.
- *
- * @since 2.0.0
- */
-const hole = /*#__PURE__*/unsafeCoerce(absurd);
-
-/**
- * The SK combinator, also known as the "S-K combinator" or "S-combinator", is a fundamental combinator in the
- * lambda calculus and the SKI combinator calculus.
- *
- * This function is useful for discarding the first argument passed to it and returning the second argument.
- *
- * @param _ - The first argument to be discarded.
- * @param b - The second argument to be returned.
- *
- * @example
- * import { SK } from "effect/Function";
- *
- * assert.deepStrictEqual(SK(0, "hello"), "hello")
- *
- * @since 2.0.0
- */
-const SK = (_, b) => b;
-
-var Function = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isFunction: isFunction,
-  dual: dual,
-  apply: apply,
-  identity: identity,
-  unsafeCoerce: unsafeCoerce,
-  constant: constant,
-  constTrue: constTrue,
-  constFalse: constFalse,
-  constNull: constNull,
-  constUndefined: constUndefined,
-  constVoid: constVoid,
-  flip: flip,
-  compose: compose,
-  absurd: absurd,
-  tupled: tupled,
-  untupled: untupled,
-  pipe: pipe,
-  flow: flow,
-  hole: hole,
-  SK: SK
-});
-
-export { Function as F, SK as S, constFalse as a, constVoid as b, constTrue as c, dual as d, constNull as e, constUndefined as f, isFunction as g, constant as h, identity as i, absurd as j, flow as k, hole as l, apply as m, flip as n, compose as o, pipe as p, untupled as q, tupled as t, unsafeCoerce as u };

package/dist/GlobalValue-b5edf230.esm.js

@@ -1,25 +0,0 @@
-/**
- * @since 2.0.0
- */
-const globalStoreId = /*#__PURE__*/Symbol.for("effect/GlobalValue/globalStoreId");
-if (!(globalStoreId in globalThis)) {
-  globalThis[globalStoreId] = /*#__PURE__*/new Map();
-}
-const globalStore = globalThis[globalStoreId];
-
-/**
- * @since 2.0.0
- */
-const globalValue = (id, compute) => {
-  if (!globalStore.has(id)) {
-    globalStore.set(id, compute());
-  }
-  return globalStore.get(id);
-};
-
-var GlobalValue = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  globalValue: globalValue
-});
-
-export { GlobalValue as G, globalValue as g };

package/dist/GroupBy-4c667347.esm.js

@@ -1,72 +0,0 @@
-import { G as GroupByTypeId$1, e as evaluate$1, f as filter$1, c as first$1, d as make$1 } from './groupBy-d11b31b1.esm.js';
-
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const GroupByTypeId = GroupByTypeId$1;
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-
-/**
- * Representation of a grouped stream. This allows to filter which groups will
- * be processed. Once this is applied all groups will be processed in parallel
- * and the results will be merged in arbitrary order.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- */
-
-/**
- * Run the function across all groups, collecting the results in an
- * arbitrary order.
- *
- * @since 2.0.0
- * @category destructors
- */
-const evaluate = evaluate$1;
-
-/**
- * Filter the groups to be processed.
- *
- * @since 2.0.0
- * @category utils
- */
-const filter = filter$1;
-
-/**
- * Only consider the first `n` groups found in the `Stream`.
- *
- * @since 2.0.0
- * @category utils
- */
-const first = first$1;
-
-/**
- * Constructs a `GroupBy` from a `Stream`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const make = make$1;
-
-var GroupBy = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  GroupByTypeId: GroupByTypeId,
-  evaluate: evaluate,
-  filter: filter,
-  first: first,
-  make: make
-});
-
-export { GroupBy as G, GroupByTypeId as a, first as b, evaluate as e, filter as f, make as m };

package/dist/HKT-1990744d.esm.js

@@ -1,5 +0,0 @@
-var HKT = /*#__PURE__*/Object.freeze({
-  __proto__: null
-});
-
-export { HKT as H };