✨ feat: Implement from and DoublyLinkedList.from.

Fixes #7.

Author: make-github-pseudonymous-again

src/DoublyLinkedList.js

@@ -1,34 +1,19 @@
+import Node from './Node.js';
+import Iterator from './Iterator.js';
+import ReverseIterator from './ReverseIterator.js';
+
 /**
  * Doubly linked list implementation
  * making use of dummy nodes for the
  * sake of simplicity.
  */
-
-export function DoublyLinkedList() {
+export default function DoublyLinkedList() {
 	this.front = new Node(null, null, null);
 	this.back = new Node(this.front, null, null);
 	this.front.next = this.back;
 	this.length = 0;
 }
 
-export function Node(prev, next, value) {
-	this.prev = prev;
-	this.next = next;
-	this.value = value;
-}
-
-export function Iterator(front, back, current) {
-	this.front = front;
-	this.back = back;
-	this.current = current;
-}
-
-export function ReverseIterator(front, back, current) {
-	this.front = front;
-	this.back = back;
-	this.current = current;
-}
-
 DoublyLinkedList.prototype.insertAfter = function (iterator, value) {
 	const prev = iterator.current;
 
@@ -170,31 +155,14 @@ DoublyLinkedList.prototype.rend = function () {
 	return this.riterator(this.front);
 };
 
-Iterator.prototype.copy = function () {
-	return new Iterator(this.front, this.back, this.current);
-};
-
-ReverseIterator.prototype.copy = function () {
-	return new ReverseIterator(this.front, this.back, this.current);
-};
-
-// eslint-disable-next-line no-multi-assign
-Iterator.prototype.next = ReverseIterator.prototype.prev = function () {
-	// eslint-disable-next-line no-multi-assign
-	const c = (this.current = this.current.next);
-
-	return c === this.back ? {done: true} : {value: c.value, done: false};
-};
-
-// eslint-disable-next-line no-multi-assign
-Iterator.prototype.prev = ReverseIterator.prototype.next = function () {
-	// eslint-disable-next-line no-multi-assign
-	const c = (this.current = this.current.prev);
-
-	return c === this.front ? {done: true} : {value: c.value, done: false};
+const from = (iterable) => {
+	const list = new DoublyLinkedList();
+	for (const value of iterable) list.push(value);
+	return list;
 };
 
 DoublyLinkedList.prototype[Symbol.iterator] = DoublyLinkedList.prototype.begin;
 DoublyLinkedList.Node = Node;
 DoublyLinkedList.Iterator = Iterator;
 DoublyLinkedList.ReverseIterator = ReverseIterator;
+DoublyLinkedList.from = from;

src/Iterator.js

@@ -0,0 +1,23 @@
+export default function Iterator(front, back, current) {
+	this.front = front;
+	this.back = back;
+	this.current = current;
+}
+
+Iterator.prototype.copy = function () {
+	return new Iterator(this.front, this.back, this.current);
+};
+
+Iterator.prototype.next = function () {
+	// eslint-disable-next-line no-multi-assign
+	const c = (this.current = this.current.next);
+
+	return c === this.back ? {done: true} : {value: c.value, done: false};
+};
+
+Iterator.prototype.prev = function () {
+	// eslint-disable-next-line no-multi-assign
+	const c = (this.current = this.current.prev);
+
+	return c === this.front ? {done: true} : {value: c.value, done: false};
+};

src/Node.js

@@ -0,0 +1,5 @@
+export default function Node(prev, next, value) {
+	this.prev = prev;
+	this.next = next;
+	this.value = value;
+}

src/ReverseIterator.js

@@ -0,0 +1,14 @@
+import Iterator from './Iterator.js';
+
+export default function ReverseIterator(front, back, current) {
+	this.front = front;
+	this.back = back;
+	this.current = current;
+}
+
+ReverseIterator.prototype.copy = function () {
+	return new ReverseIterator(this.front, this.back, this.current);
+};
+
+ReverseIterator.prototype.prev = Iterator.prototype.next;
+ReverseIterator.prototype.next = Iterator.prototype.prev;

src/index.js

@@ -1 +1,7 @@
-export * from './DoublyLinkedList.js';
+import DoublyLinkedList from './DoublyLinkedList.js';
+
+export {default as DoublyLinkedList} from './DoublyLinkedList.js';
+export {default as Iterator} from './Iterator.js';
+export {default as Node} from './Node.js';
+export {default as ReverseIterator} from './ReverseIterator.js';
+export const from = DoublyLinkedList.from;

test/src/DoublyLinkedList.js

@@ -1,8 +1,8 @@
 import test from 'ava';
-import * as dll from '#module';
+import {DoublyLinkedList} from '#module';
 
 test('DoublyLinkedList', (t) => {
-	const list = new dll.DoublyLinkedList();
+	const list = new DoublyLinkedList();
 
 	const a = list.push(1);
 	const b = list.push(2);

test/src/from.js

@@ -0,0 +1,24 @@
+import test from 'ava';
+import {from, DoublyLinkedList} from '#module';
+
+test('from is DoublyLinkedList.from', (t) => {
+	t.is(from, DoublyLinkedList.from);
+});
+
+const macro = test.macro({
+	exec(t, sequence) {
+		const expected = Array.from(sequence);
+		const list = DoublyLinkedList.from(sequence);
+		t.deepEqual(Array.from(list), expected);
+	},
+	title(title, sequence) {
+		return title ?? `from(${JSON.stringify(sequence)})`;
+	},
+});
+
+test(macro, []);
+test(macro, [1]);
+test(macro, [1, 2, 3]);
+test(macro, '');
+test(macro, 'a');
+test(macro, 'ab');