🚧 progress: Import existing sources, tests, and code samples.

Author: make-github-pseudonymous-again

README.md

@@ -4,13 +4,16 @@
 Set closure for JavaScript.
 See [docs](https://set-theory.github.io/closure/index.html).
 
-> :building_construction: Caveat emptor! This is work in progress. Code may be
-> working. Documentation may be present. Coherence may be. Maybe.
-
 > :warning: Depending on your environment, the code may require
 > `regeneratorRuntime` to be defined, for instance by importing
 > [regenerator-runtime/runtime](https://www.npmjs.com/package/regenerator-runtime).
 
+
+```js
+import {closure} from '@set-theory/closure';
+closure( x => x + 1 , 0 ) ; // 0 1 2 3 ...
+```
+
 [![License](https://img.shields.io/github/license/set-theory/closure.svg)](https://raw.githubusercontent.com/set-theory/closure/main/LICENSE)
 [![Version](https://img.shields.io/npm/v/@set-theory/closure.svg)](https://www.npmjs.org/package/@set-theory/closure)
 [![Tests](https://img.shields.io/github/workflow/status/set-theory/closure/ci:test?event=push&label=tests)](https://github.com/set-theory/closure/actions/workflows/ci:test.yml?query=branch:main)

package.json

@@ -65,6 +65,9 @@
     "@babel/preset-env": "7.14.0",
     "@babel/register": "7.13.16",
     "@commitlint/cli": "12.1.1",
+    "@iterable-iterator/list": "^0.0.2",
+    "@iterable-iterator/slice": "^0.0.1",
+    "@iterable-iterator/zip": "^0.0.2",
     "@js-library/commitlint-config": "0.0.4",
     "ava": "3.15.0",
     "babel-plugin-transform-remove-console": "6.9.4",

src/closure.js

@@ -0,0 +1,28 @@
+/**
+ * Computes the closure of a unary operator, starting from a single element.
+ *
+ * @experimental Should handle d-ary operators in the future. Not sure the name
+ * is well chosen. An actual closure function would keep track of encountered
+ * elements to stop when all elements have been found.
+ *
+ * @example
+ * closure( x => x + 1 , 0 ) ; // 0 1 2 3 ...
+ *
+ * @example
+ * closure( x => x * 2 , 1 ) ; // 1 2 4 8 ...
+ *
+ * @param {Function} operator The operator.
+ * @param {Object} start The starting element.
+ * @returns {Iterator} Iterator over the closure.
+ */
+export default function* closure(operator, start) {
+	yield start;
+
+	let element = start;
+
+	while (true) {
+		element = operator(element);
+
+		yield element;
+	}
+}

src/index.js

@@ -1,2 +1 @@
-const answer = 42;
-export default answer;
+export {default as closure} from './closure.js';

test/src/api.js

@@ -0,0 +1,97 @@
+import test from 'ava';
+
+import {list} from '@iterable-iterator/list';
+import {enumerate} from '@iterable-iterator/zip';
+import {takewhile} from '@iterable-iterator/slice';
+
+import {closure} from '../../src/index.js';
+
+// https://oeis.org/A006577
+const Collatz = (x) => (x % 2 === 1 ? 3 * x + 1 : Math.floor(x / 2));
+
+const A006577 = [
+	0,
+	1,
+	7,
+	2,
+	5,
+	8,
+	16,
+	3,
+	19,
+	6,
+	14,
+	9,
+	9,
+	17,
+	17,
+	4,
+	12,
+	20,
+	20,
+	7,
+	7,
+	15,
+	15,
+	10,
+	23,
+	10,
+	111,
+	18,
+	18,
+	18,
+	106,
+	5,
+	26,
+	13,
+	13,
+	21,
+	21,
+	21,
+	34,
+	8,
+	109,
+	8,
+	29,
+	16,
+	16,
+	16,
+	104,
+	11,
+	24,
+	24,
+	24,
+	11,
+	11,
+	112,
+	112,
+	19,
+	32,
+	19,
+	32,
+	19,
+	19,
+	107,
+	107,
+	6,
+	27,
+	27,
+	27,
+	14,
+	14,
+	14,
+	102,
+	22,
+];
+
+function macro(t, n, a) {
+	const sequence = list(takewhile((x) => x !== 1, closure(Collatz, n)));
+
+	t.is(sequence.length, a);
+}
+
+macro.title = (_, n, a) => `closure [A006577] > a(${n}) = ${a}`;
+
+for (const [n, a] of enumerate(A006577, 1)) {
+	test(macro, n, a);
+}