✨ feat: First draft.

Author: make-github-pseudonymous-again

package.json

@@ -75,7 +75,10 @@
   "bugs": {
     "url": "https://github.com/aureooms/js-persistent-stack/issues"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@aureooms/js-error": "^4.0.1",
+    "@aureooms/js-itertools": "^4.1.0"
+  },
   "devDependencies": {
     "@babel/cli": "7.11.6",
     "@babel/core": "7.11.6",
@@ -101,7 +104,12 @@
     "lib"
   ],
   "homepage": "https://aureooms.github.io/js-persistent-stack",
-  "keywords": ["data", "persistent", "stack", "structures"],
+  "keywords": [
+    "data",
+    "persistent",
+    "stack",
+    "structures"
+  ],
   "license": "AGPL-3.0",
   "main": "lib/index.js",
   "prettier": {
@@ -133,12 +141,7 @@
       "unicorn"
     ],
     "rules": {
-      "unicorn/filename-case": [
-        "error",
-        {
-          "case": "camelCase"
-        }
-      ]
+      "unicorn/filename-case": "off"
     }
   }
 }

src/DONE_ITERATOR.js

@@ -0,0 +1,3 @@
+function* _emptyGenerator() {}
+const DONE_ITERATOR = _emptyGenerator();
+export default DONE_ITERATOR;

src/index.js

@@ -0,0 +1,8 @@
+import DONE_ITERATOR from './DONE_ITERATOR';
+import withMethods from './withMethods';
+import withoutMethods from './withoutMethods';
+
+/* eslint import/no-anonymous-default-export: [2, {"allowObject": true}] */
+export default withoutMethods;
+
+export {DONE_ITERATOR, withMethods, withoutMethods};

src/withMethods.js

@@ -0,0 +1,58 @@
+import {TypeError} from '@aureooms/js-error';
+import {_reduce} from '@aureooms/js-itertools';
+
+export default function PersistentStack() {}
+PersistentStack.prototype.push = function (value) {
+	return new Pushed(value, this);
+};
+
+PersistentStack.prototype[Symbol.iterator] = function* () {
+	let current = this;
+	while (!current.isEmpty()) {
+		yield current.peek();
+		current = current.pop();
+	}
+};
+
+function Empty() {}
+Empty.prototype = new PersistentStack();
+
+Empty.prototype.isEmpty = function () {
+	return true;
+};
+
+Empty.prototype.pop = function () {
+	throw new TypeError('Cannot call pop on empty stack.');
+};
+
+Empty.prototype.peek = function () {
+	throw new TypeError('Cannot call peek on empty stack.');
+};
+
+function Pushed(value, next) {
+	this.value = value;
+	this.next = next;
+}
+
+Pushed.prototype = new PersistentStack();
+Pushed.prototype.isEmpty = function () {
+	return false;
+};
+
+Pushed.prototype.pop = function () {
+	return this.next;
+};
+
+Pushed.prototype.peek = function () {
+	return this.value;
+};
+
+const EMPTY = new Empty();
+PersistentStack.empty = () => EMPTY;
+PersistentStack.push = (stack, value) => new Pushed(value, stack);
+PersistentStack.isEmpty = (stack) => stack.isEmpty();
+PersistentStack.pop = (stack) => stack.pop();
+PersistentStack.peek = (stack) => stack.peek();
+PersistentStack.iter = (stack) => stack[Symbol.iterator]();
+PersistentStack.from = (iterable) =>
+	_reduce(PersistentStack.push, iterable, EMPTY);

src/withoutMethods.js

@@ -0,0 +1,37 @@
+import {_reduce} from '@aureooms/js-itertools';
+import DONE_ITERATOR from './DONE_ITERATOR';
+
+function Node(value, next) {
+	this.value = value;
+	this.next = next;
+}
+
+Node.prototype[Symbol.iterator] = function* () {
+	let current = this;
+	while (current !== null) {
+		yield current.value;
+		current = current.next;
+	}
+};
+
+const empty = () => null;
+const from = (iterable) => _reduce(push, iterable, null);
+const isEmpty = (stack) => stack === null;
+const push = (stack, value) => new Node(value, stack);
+const pop = (stack) => stack.next;
+const peek = (stack) => stack.value;
+const iter = (stack) =>
+	stack === null ? DONE_ITERATOR : stack[Symbol.iterator]();
+
+const withoutMethods = {
+	name: 'withoutMethods',
+	empty,
+	from,
+	isEmpty,
+	push,
+	pop,
+	peek,
+	iter,
+};
+
+export default withoutMethods;

test/src/api.js

@@ -0,0 +1,59 @@
+import test from 'ava';
+
+import {product} from '@aureooms/js-itertools';
+
+import {withMethods, withoutMethods} from '../../src';
+
+function macro(t, {empty, isEmpty, push, pop, peek}, n) {
+	const array = [];
+
+	let stack = empty();
+	t.true(isEmpty(stack), 'At the begining, stack is empty.');
+	t.throws(
+		() => peek(stack),
+		null,
+		'At the beginning, calling peek on empty stack throws.',
+	);
+	t.throws(
+		() => pop(stack),
+		null,
+		'At the beginning, calling pop on empty stack throws.',
+	);
+
+	for (let i = 0; i < n; ++i) {
+		const r = Math.random();
+
+		stack = push(stack, r);
+		array.push(r);
+
+		t.false(isEmpty(stack), i + 'The stack is not empty.');
+
+		t.deepEqual(peek(stack), r, i + ' Peek returns the last value.');
+	}
+
+	for (let i = 0; i < n; ++i) {
+		t.false(isEmpty(stack), i + 'The stack is not empty.');
+
+		t.deepEqual(peek(stack), array.pop(), i + ' Pop works.');
+		stack = pop(stack);
+	}
+
+	t.true(isEmpty(stack), 'At the end, stack is empty.');
+	t.throws(
+		() => peek(stack),
+		null,
+		'At the end, calling peek on empty stack throws.',
+	);
+	t.throws(
+		() => pop(stack),
+		null,
+		'At the end, calling pop on empty stack throws.',
+	);
+}
+
+const implementations = [withMethods, withoutMethods];
+const sizes = [0, 1, 2, 10, 42, 100, 121, 197, 1024, 2500];
+
+for (const [implementation, n] of product([implementations, sizes])) {
+	test(`api: ${implementation.name} <${n}>`, macro, implementation, n);
+}

test/src/errors.js

@@ -0,0 +1,14 @@
+import test from 'ava';
+
+import {withMethods, withoutMethods} from '../../src';
+
+function macro(t, {empty, peek, pop}) {
+	t.throws(() => peek(empty()), null, 'Cannot peek empty.');
+	t.throws(() => pop(empty()), null, 'Cannot pop empty.');
+}
+
+const implementations = [withMethods, withoutMethods];
+
+for (const implementation of implementations) {
+	test(`errors: ${implementation.name}`, macro, implementation);
+}

test/src/from.js

@@ -0,0 +1,29 @@
+import test from 'ava';
+
+import {product, range, list, reversed} from '@aureooms/js-itertools';
+
+import {withMethods, withoutMethods} from '../../src';
+
+function macro(t, {from, iter, isEmpty}, n) {
+	const stack = from(range(n));
+	if (n === 0) t.true(isEmpty(stack), 'The stack is empty.');
+	else t.false(isEmpty(stack), 'The stack is not empty.');
+
+	t.deepEqual(
+		list(reversed(range(n))),
+		list(iter(stack)),
+		'All items are in the stack in order.',
+	);
+	t.deepEqual(
+		list(reversed(range(n))),
+		list(iter(stack)),
+		'Can be iterated two times.',
+	);
+}
+
+const implementations = [withMethods, withoutMethods];
+const sizes = [0, 1, 2, 10, 42, 100, 121, 197, 1024, 2500];
+
+for (const [implementation, n] of product([implementations, sizes])) {
+	test(`from: ${implementation.name} <${n}>`, macro, implementation, n);
+}

test/src/immutability.js

@@ -0,0 +1,49 @@
+import test from 'ava';
+
+import {product, enumerate, list, zip} from '@aureooms/js-itertools';
+
+import {withMethods, withoutMethods} from '../../src';
+
+function macro(t, {empty, push, pop, iter}, n) {
+	const array = [];
+	let stack = empty();
+
+	const pushed = [stack];
+	for (let i = 0; i < n; ++i) {
+		const r = Math.random();
+		stack = push(stack, r);
+		pushed.push(stack);
+		array.push(r);
+	}
+
+	const popped = [stack];
+	for (let i = 0; i < n; ++i) {
+		stack = pop(stack);
+		popped.push(stack);
+	}
+
+	popped.reverse();
+
+	for (const [i, [A, B]] of enumerate(zip(pushed, popped))) {
+		const values = array.slice(0, i).reverse();
+
+		t.deepEqual(
+			values,
+			list(iter(A)),
+			'All items are in order in the pushed stack.',
+		);
+
+		t.deepEqual(
+			values,
+			list(iter(B)),
+			'All items are in order in the popped stack.',
+		);
+	}
+}
+
+const implementations = [withMethods, withoutMethods];
+const sizes = [0, 1, 2, 10, 42, 100, 121, 197, 1024, 2500];
+
+for (const [implementation, n] of product([implementations, sizes])) {
+	test(`immutability: ${implementation.name} <${n}>`, macro, implementation, n);
+}

test/src/methods.js

@@ -0,0 +1,61 @@
+import test from 'ava';
+
+import {TypeError} from '@aureooms/js-error';
+import {product} from '@aureooms/js-itertools';
+
+import {withMethods} from '../../src';
+
+function macro(t, {empty}, n) {
+	const array = [];
+
+	let stack = empty();
+	t.true(stack.isEmpty(), 'At the begining, stack is empty.');
+	t.throws(
+		() => stack.peek(),
+		{instanceOf: TypeError},
+		'At the beginning, calling peek on empty stack throws type error.',
+	);
+	t.throws(
+		() => stack.pop(),
+		{instanceOf: TypeError},
+		'At the beginning, calling pop on empty stack throws type error.',
+	);
+
+	for (let i = 0; i < n; ++i) {
+		const r = Math.random();
+
+		stack = stack.push(r);
+		array.push(r);
+
+		t.false(stack.isEmpty(), i + 'The stack is not empty.');
+
+		t.deepEqual(stack.peek(), r, i + ' Peek returns the last value.');
+	}
+
+	for (let i = 0; i < n; ++i) {
+		t.false(stack.isEmpty(), i + 'The stack is not empty.');
+
+		t.deepEqual(stack.peek(), array.pop(), i + ' Pop works.');
+		stack = stack.pop();
+	}
+
+	t.true(stack.isEmpty(), 'At the end, stack is empty.');
+
+	t.throws(
+		() => stack.peek(),
+		{instanceOf: TypeError},
+		'At the end, calling peek on empty stack throws type error.',
+	);
+	t.throws(
+		() => stack.pop(),
+		{instanceOf: TypeError},
+		'At the end, calling pop on empty throws type error.',
+	);
+}
+
+const implementations = [withMethods];
+const sizes = [0, 1, 2, 10, 42, 100, 121, 197, 1024, 2500];
+
+for (const [implementation, n] of product([implementations, sizes])) {
+	test(`methods: ${implementation.name} <${n}>`, macro, implementation, n);
+}