Repo setup

Author: timonson

.github/workflows/test.yml

@@ -0,0 +1,40 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: test-${{ matrix.deno }}-${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        deno: [old, stable, canary]
+        os: [macOS-latest, windows-latest, ubuntu-latest]
+
+    steps:
+      - name: Setup repo
+        uses: actions/checkout@v2
+
+      - name: Setup Deno
+        run: |
+          curl -fsSL https://deno.land/x/install/install.sh | sh ${{ matrix.deno == 'old' && '-s v1.35.0' || '' }}
+          echo "$HOME/.deno/bin" >> $${{ runner.os == 'Windows' && 'env:' || '' }}GITHUB_PATH
+      - name: Upgrade to Deno canary
+        if: matrix.deno == 'canary'
+        run: deno upgrade --canary
+
+      - name: Format
+        if: runner.os == 'Linux'
+        run: deno fmt --check
+
+      - name: Lint
+        if: runner.os == 'Linux'
+        run: deno lint --unstable
+
+          #    - name: Run Tests
+          # run: deno test --unstable --check -A 

.gitignore

@@ -0,0 +1,4 @@
+.*
+!/.github
+!/.gitignore
+deno.lock

README.md

@@ -0,0 +1,11 @@
+# sorcery
+
+Input, computation and output. That's all sorcery!
+
+## Todo
+
+Fix `collections` for strings and other iterables.
+
+## Credit
+
+https://github.com/sekwiatkowski

arrays/aggregation.js

@@ -0,0 +1,236 @@
+import { equals } from "../booleans/equality.js";
+import { identity } from "../higher_order.js";
+import { defaultValue } from "../type.js";
+
+/**
+ * Takes a callback of three arguments (`acc`, `el`, `i`), an initial value and
+ * an array. It returns an accumulated result.
+ * ```ts
+ * function toUpperCase(acc, el) {
+ *   console.log("el:", el);
+ *   return acc += el.toUpperCase();
+ * }
+ * const arrS = ["uno", "dos", "tres", "quattro", "cinco"];
+ *  fold(toUpperCase)("initialValue")(arrS);
+ * ```
+ */
+function fold(f) {
+  return (initialValue) => (arr) => {
+    let acc = initialValue;
+
+    for (let i = 0; i < arr.length; i++) {
+      acc = f(acc, arr[i], i);
+    }
+
+    return acc;
+  };
+}
+
+/**
+ * Takes a predicate of three arguments, a callback of three arguments, an initial
+ * value and an array. It accumulates its result while the predicate returns `true`.
+ * ```ts
+ * foldWhile(isString)(toUpperCase)("initialValue")(arrS);
+ * ```
+ */
+function foldWhile(predicate) {
+  return (f) => (initialValue) => (arr) => {
+    let acc = initialValue;
+
+    for (let i = 0; i < arr.length; i++) {
+      const item = arr[i];
+      if (!predicate(acc, item, i)) {
+        return acc;
+      }
+      acc = f(acc, item, i);
+    }
+    return acc;
+  };
+}
+
+/**
+ * Takes a callback of three arguments and an array. It uses the first element
+ * of the array as initial value and returns an accumulated result.
+ * ```ts
+ * function add(a, b) {
+ *   return a + b;
+ * }
+ * const arrN = [10, 20, 30, 40, 50];
+ * reduce(add)(arrN);
+ * ```
+ */
+function reduce(f) {
+  return (arr) => {
+    let acc = arr[0];
+
+    for (let i = 1; i < arr.length; i++) {
+      acc = f(acc, arr[i], i);
+    }
+
+    return acc;
+  };
+}
+
+const count = countBy(identity);
+
+/**
+ * Creates an object composed of keys generated from the results of running each
+ * element of collection thru iteratee. The corresponding value of each key is
+ * the number of times the key was returned by iteratee.
+ * @template I,N
+ * @param {(item: I) => N} f
+ * @returns {(arr: I[]) => Record<string, number>}
+ */
+function countBy(f) {
+  return (arr) => {
+    const counts = {};
+
+    for (const item of arr) {
+      const key = f(item);
+      const currentCount = defaultValue(0)(counts[key]);
+      counts[key] = currentCount + 1;
+    }
+
+    return counts;
+  };
+}
+
+/**
+ * countIf.
+ *
+ * @param {} predicate
+ */
+function countIf(predicate) {
+  return (arr) => {
+    let counter = 0;
+
+    for (const item of arr) {
+      if (predicate(item)) {
+        counter += 1;
+      }
+    }
+
+    return counter;
+  };
+}
+
+/**
+ * countOf.
+ *
+ * @param {} value
+ */
+function countOf(value) {
+  return (arr) => countIf(equals(value))(arr);
+}
+
+/**
+ * min.
+ *
+ * @param {} arr
+ */
+function min(arr) {
+  if (arguments.length > 1) {
+    return min(Array.prototype.slice.call(arguments));
+  }
+
+  return Math.min(...arr);
+}
+
+/**
+ * minBy.
+ *
+ * @param {} f
+ */
+function minBy(f) {
+  return (arr) => {
+    let lowestScore = Number.POSITIVE_INFINITY;
+    let index = -1;
+
+    for (let i = 0; i < arr.length; i++) {
+      const score = f(arr[i]);
+
+      if (score < lowestScore) {
+        lowestScore = score;
+        index = i;
+      }
+    }
+
+    return arr[index];
+  };
+}
+
+/**
+ * max.
+ *
+ * @param {} arr
+ */
+function max(arr) {
+  if (arguments.length > 1) {
+    return max(Array.prototype.slice.call(arguments));
+  }
+
+  return Math.max(...arr);
+}
+
+/**
+ * maxBy.
+ *
+ * @param {} f
+ */
+function maxBy(f) {
+  return (arr) => {
+    let highestScore = Number.NEGATIVE_INFINITY;
+    let index = -1;
+
+    for (let i = 0; i < arr.length; i++) {
+      const score = f(arr[i]);
+
+      if (score > highestScore) {
+        highestScore = score;
+        index = i;
+      }
+    }
+
+    return arr[index];
+  };
+}
+
+/**
+ * sumBy.
+ *
+ * @param {} f
+ */
+function sumBy(f) {
+  return (xs) => fold((acc, x) => acc + f(x))(0)(xs);
+}
+
+const sum = sumBy(identity);
+
+/**
+ * productBy.
+ *
+ * @param {} f
+ */
+function productBy(f) {
+  return (xs) => fold((acc, x) => acc * f(x))(1)(xs);
+}
+
+const product = productBy(identity);
+
+export {
+  count,
+  countBy,
+  countIf,
+  countOf,
+  fold,
+  foldWhile,
+  max,
+  maxBy,
+  min,
+  minBy,
+  product,
+  productBy,
+  reduce,
+  sum,
+  sumBy,
+};

arrays/creation.js

@@ -0,0 +1,56 @@
+function fill(value) {
+  return (n) => {
+    const result = Array(n);
+
+    for (let i = 0; i < n; i++) {
+      result[i] = value;
+    }
+
+    return result;
+  };
+}
+
+function fillWith1ToN(n) {
+  return Array.from(Array(n).keys());
+}
+
+function range(inclusiveStart) {
+  return (exclusiveEnd) => {
+    return steps(inclusiveStart)(exclusiveEnd)(1);
+  };
+}
+
+function inclusiveRange(inclusiveStart) {
+  return (inclusiveEnd) => {
+    return range(inclusiveStart)(inclusiveEnd + 1);
+  };
+}
+
+function steps(inclusiveStart) {
+  return (exclusiveEnd) => (stepSize) => {
+    const size = Math.ceil((exclusiveEnd - inclusiveStart) / stepSize);
+
+    if (size < 1) {
+      return [];
+    }
+
+    const result = Array(size);
+
+    for (
+      let i = 0, current = inclusiveStart;
+      i < size;
+      i++, current += stepSize
+    ) {
+      result[i] = current;
+    }
+
+    return result;
+  };
+}
+
+function inclusiveSteps(inclusiveStart) {
+  return (inclusiveEnd) => (stepSize) =>
+    steps(inclusiveStart)(inclusiveEnd + 1)(stepSize);
+}
+
+export { fill, fillWith1ToN, inclusiveRange, inclusiveSteps, range, steps };