💥 refactor!: Rename isleaf to isLeaf.

BREAKING CHANGE: This breaks dependents relying on this method.

Author: make-github-pseudonymous-again

src/adt/Leaf.js

@@ -18,6 +18,6 @@ export function Leaf(parent) {
  *
  * @returns {Boolean}
  */
-Leaf.prototype.isleaf = function () {
+Leaf.prototype.isLeaf = function () {
 	return true;
 };

src/adt/Node.js

@@ -22,6 +22,6 @@ export function Node(color, key) {
  *
  * @returns {Boolean}
  */
-Node.prototype.isleaf = function () {
+Node.prototype.isLeaf = function () {
 	return false;
 };

src/adt/RedBlackTree.js

@@ -80,15 +80,15 @@ export class RedBlackTree {
 	 * @param {Node} node - The input node to delete.
 	 */
 	_delete(node) {
-		if (!node.left.isleaf()) {
+		if (!node.left.isLeaf()) {
 			// Replace node's key with predecessor's key
 			const pred = predecessor(node);
 			node.key = pred.key;
 			// Delete predecessor node
 			// note: this node can only have one non-leaf child
 			//       because the tree is a red-black tree
 			delete_one_child(pred);
-		} else if (!node.right.isleaf()) {
+		} else if (!node.right.isLeaf()) {
 			// Replace node's key with successor's key
 			// If there is no left child, then there can only be one right
 			// child.

src/debug/debug.js

@@ -9,7 +9,7 @@ import {BLACK} from '../color/BLACK.js';
  */
 export function _debug({red, black}) {
 	const debug = (root) => {
-		if (root.isleaf()) return black('L');
+		if (root.isLeaf()) return black('L');
 
 		const repr = root.color === BLACK ? black(root.key) : red(root.key);
 

src/deletion/delete_one_child.js

@@ -14,9 +14,9 @@ import {delete_case1} from './delete_case1.js';
  */
 export function delete_one_child(n) {
 	// Precondition: n has at most one non-leaf child.
-	// assert( n.right.isleaf() || n.left.isleaf());
+	// assert( n.right.isLeaf() || n.left.isLeaf());
 
-	// const child = n.right.isleaf() ? n.left : n.right;
+	// const child = n.right.isLeaf() ? n.left : n.right;
 	// n.right is always a LEAF because either n is a subtree predecessor or it
 	// is the only child of its parent by the red-black tree properties
 	const child = n.left;

src/family/predecessor.js

@@ -6,10 +6,10 @@
  * @returns {Node}
  */
 export function predecessor(node) {
-	// Assert( !node.left.isleaf() ) ;
+	// Assert( !node.left.isLeaf() ) ;
 	let pred = node.left;
 
-	while (!pred.right.isleaf()) pred = pred.right;
+	while (!pred.right.isLeaf()) pred = pred.right;
 
 	return pred;
 }

src/family/uncle.js

@@ -11,6 +11,6 @@ export function uncle(node) {
 	const g = grandparent(node);
 	// Assert( g !== null ) ;
 	// this can never happen
-	if (node.parent === g.left) return g.right.isleaf() ? null : g.right;
-	return g.left.isleaf() ? null : g.left;
+	if (node.parent === g.left) return g.right.isLeaf() ? null : g.right;
+	return g.left.isLeaf() ? null : g.left;
 }

src/insertion/insert.js

@@ -19,7 +19,7 @@ export function insert(compare, A, B) {
 		if (compare(B.key, A.key) < 0) {
 			const node = A.left;
 
-			if (node.isleaf()) {
+			if (node.isLeaf()) {
 				A.left = B;
 				break;
 			}
@@ -28,7 +28,7 @@ export function insert(compare, A, B) {
 		} else {
 			const node = A.right;
 
-			if (node.isleaf()) {
+			if (node.isLeaf()) {
 				A.right = B;
 				break;
 			}

src/search/search.js

@@ -16,7 +16,7 @@ export function search(compare, root, key) {
 
 		root = d < 0 ? root.left : root.right;
 
-		if (root.isleaf()) {
+		if (root.isLeaf()) {
 			return null;
 		}
 	}

src/traversal/inordertraversal.js

@@ -5,7 +5,7 @@
  * @returns {Iterator}
  */
 export function* inordertraversal(node) {
-	if (!node.left.isleaf()) {
+	if (!node.left.isLeaf()) {
 		// Yield the nodes on the left recursively. Those nodes are all smaller
 		// than (or equal to) the current node by the binary search tree
 		// properties.
@@ -15,7 +15,7 @@ export function* inordertraversal(node) {
 	// Yield the current node.
 	yield node.key;
 
-	if (!node.right.isleaf()) {
+	if (!node.right.isLeaf()) {
 		// Yield the nodes on the right recursively. Those nodes are all larger
 		// than (or equal to) the current node by the binary search tree
 		// properties.

src/traversal/rangetraversal.js

@@ -12,20 +12,20 @@ export function* rangetraversal(compare, root, left, right) {
 	if (compare(root.key, left) < 0) {
 		// If the root lies to the left of the interval, we can discard the
 		// entire left subtree.
-		if (!root.right.isleaf())
+		if (!root.right.isLeaf())
 			yield* rangetraversal(compare, root.right, left, right);
 	} else if (compare(root.key, right) >= 0) {
 		// If the root lies to the right of the interval, we can discard the
 		// entire right subtree.
-		if (!root.left.isleaf())
+		if (!root.left.isLeaf())
 			yield* rangetraversal(compare, root.left, left, right);
 	} else {
 		// Otherwise just recurse on both subtrees and yield the root in
 		// between.
-		if (!root.left.isleaf())
+		if (!root.left.isLeaf())
 			yield* rangetraversal(compare, root.left, left, right);
 		yield root.key;
-		if (!root.right.isleaf())
+		if (!root.right.isLeaf())
 			yield* rangetraversal(compare, root.right, left, right);
 	}
 }