@nlozgachev/pipelined 0.12.0 → 0.13.0

package/dist/composition.mjs

@@ -0,0 +1,135 @@
+// src/Composition/compose.ts
+function compose(...fns) {
+  return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
+}
+
+// src/Composition/converge.ts
+function converge(f, transformers) {
+  return (a) => f(...transformers.map((t) => t(a)));
+}
+
+// src/Composition/curry.ts
+var curry = (f) => (a) => (b) => f(a, b);
+var curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
+var curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);
+
+// src/Composition/flip.ts
+var flip = (f) => (b) => (a) => f(a)(b);
+
+// src/Composition/flow.ts
+function flow(...fns) {
+  return (...args) => {
+    if (fns.length === 0) return args[0];
+    const [first, ...rest] = fns;
+    return rest.reduce((acc, fn) => fn(acc), first(...args));
+  };
+}
+
+// src/Composition/fn.ts
+var identity = (a) => a;
+var constant = (a) => () => a;
+var constTrue = () => true;
+var constFalse = () => false;
+var constNull = () => null;
+var constUndefined = () => void 0;
+var constVoid = () => {
+};
+var and = (p1, p2) => (...args) => p1(...args) && p2(...args);
+var or = (p1, p2) => (...args) => p1(...args) || p2(...args);
+var once = (f) => {
+  let called = false;
+  let result;
+  return () => {
+    if (!called) {
+      result = f();
+      called = true;
+    }
+    return result;
+  };
+};
+
+// src/Composition/juxt.ts
+function juxt(fns) {
+  return (a) => fns.map((f) => f(a));
+}
+
+// src/Composition/memoize.ts
+var memoize = (f, keyFn = (a) => a) => {
+  const cache = /* @__PURE__ */ new Map();
+  return (a) => {
+    const key = keyFn(a);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = f(a);
+    cache.set(key, result);
+    return result;
+  };
+};
+var memoizeWeak = (f) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (a) => {
+    if (cache.has(a)) {
+      return cache.get(a);
+    }
+    const result = f(a);
+    cache.set(a, result);
+    return result;
+  };
+};
+
+// src/Composition/not.ts
+var not = (predicate) => (...args) => !predicate(...args);
+
+// src/Composition/on.ts
+var on = (f, g) => (a, b) => f(g(a), g(b));
+
+// src/Composition/pipe.ts
+function pipe(a, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), a);
+}
+
+// src/Composition/tap.ts
+var tap = (f) => (a) => {
+  f(a);
+  return a;
+};
+
+// src/Composition/uncurry.ts
+function uncurry(f) {
+  return (...args) => {
+    const inner = f(...args.slice(0, f.length));
+    return inner.length === 0 ? inner() : inner(...args.slice(f.length));
+  };
+}
+var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
+var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
+export {
+  and,
+  compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  converge,
+  curry,
+  curry3,
+  curry4,
+  flip,
+  flow,
+  identity,
+  juxt,
+  memoize,
+  memoizeWeak,
+  not,
+  on,
+  once,
+  or,
+  pipe,
+  tap,
+  uncurry,
+  uncurry3,
+  uncurry4
+};