consistently renamed value to element (#42)

kubikowski · Oct 28, 2022 · 531d4e6 · 531d4e6
1 parent a753c88
commit 531d4e6
Show file tree

Hide file tree

Showing 11 changed files with 30 additions and 30 deletions.
diff --git a/src/comparisons/disjoint.function.ts b/src/comparisons/disjoint.function.ts
@@ -15,13 +15,13 @@ export function disjoint<T, S extends ReadonlySet<T>>(...sets: S[]): boolean {
 		return true;
 	}
 
-	const allValues = new Set<T>(sets[0]);
+	const allElements = new Set<T>(sets[0]);
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of sets[index]!) {
-			if (allValues.has(value)) {
+		for (const element of sets[index]!) {
+			if (allElements.has(element)) {
 				return false;
 			} else {
-				allValues.add(value);
+				allElements.add(element);
 			}
 		}
 	}

diff --git a/src/comparisons/equivalence.function.ts b/src/comparisons/equivalence.function.ts
@@ -3,7 +3,7 @@ export function equivalence<T>(...sets: ReadonlySet<T>[]): boolean;
 
 /**
  * Sets are equivalent if they have the same cardinality,
- * and there is a bijection between the values contained in each set.
+ * and there is a bijection between the elements contained in each set.
  * Set equivalence is also commonly referred to as equals.
  *
  * Set equivalence is notated A ∼ B,
@@ -25,9 +25,9 @@ export function equivalence<T, S extends ReadonlySet<T>>(...sets: S[]): boolean
 		return false;
 	}
 
-	for (const value of sets[0]!) {
+	for (const element of sets[0]!) {
 		for (let index = 1; index < sets.length; index++) {
-			if (!sets[index]?.has(value)) {
+			if (!sets[index]?.has(element)) {
 				return false;
 			}
 		}

diff --git a/src/comparisons/proper-subset.function.ts b/src/comparisons/proper-subset.function.ts
@@ -25,9 +25,9 @@ export function properSubset<T, S extends ReadonlySet<T>>(...sets: S[]): boolean
 		return false;
 	}
 
-	for (const value of sets[0]!) {
+	for (const element of sets[0]!) {
 		for (let index = 1; index < sets.length; index++) {
-			if (!sets[index]?.has(value)) {
+			if (!sets[index]?.has(element)) {
 				return false;
 			}
 		}

diff --git a/src/comparisons/proper-superset.function.ts b/src/comparisons/proper-superset.function.ts
@@ -26,8 +26,8 @@ export function properSuperset<T, S extends ReadonlySet<T>>(...sets: S[]): boole
 	}
 
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of sets[index]!) {
-			if (!sets[0]?.has(value)) {
+		for (const element of sets[index]!) {
+			if (!sets[0]?.has(element)) {
 				return false;
 			}
 		}

diff --git a/src/comparisons/subset.function.ts b/src/comparisons/subset.function.ts
@@ -24,9 +24,9 @@ export function subset<T, S extends ReadonlySet<T>>(...sets: S[]): boolean {
 		return false;
 	}
 
-	for (const value of sets[0]!) {
+	for (const element of sets[0]!) {
 		for (let index = 1; index < sets.length; index++) {
-			if (!sets[index]?.has(value)) {
+			if (!sets[index]?.has(element)) {
 				return false;
 			}
 		}

diff --git a/src/comparisons/superset.function.ts b/src/comparisons/superset.function.ts
@@ -27,8 +27,8 @@ export function superset<T, S extends ReadonlySet<T>>(...sets: S[]): boolean {
 	}
 
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of sets[index]!) {
-			if (!sets[0]?.has(value)) {
+		for (const element of sets[index]!) {
+			if (!sets[0]?.has(element)) {
 				return false;
 			}
 		}

diff --git a/src/operations/difference.function.ts b/src/operations/difference.function.ts
@@ -14,8 +14,8 @@ export function difference<T, S extends ReadonlySet<T>>(...sets: S[]): S {
 	const result = new Set<T>(sets[0]);
 
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of sets[index]!) {
-			result.delete(value);
+		for (const element of sets[index]!) {
+			result.delete(element);
 		}
 	}
 

diff --git a/src/operations/intersection.function.ts b/src/operations/intersection.function.ts
@@ -12,9 +12,9 @@ export function intersection<T, S extends ReadonlySet<T>>(...sets: S[]): S {
 	const result = new Set<T>(sets[0]);
 
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of result) {
-			if (!sets[index]!.has(value)) {
-				result.delete(value);
+		for (const element of result) {
+			if (!sets[index]!.has(element)) {
+				result.delete(element);
 			}
 		}
 	}

diff --git a/src/operations/union.function.ts b/src/operations/union.function.ts
@@ -12,8 +12,8 @@ export function union<T, S extends ReadonlySet<T>>(...sets: S[]): S {
 	const result = new Set<T>(sets[0]);
 
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of sets[index]!) {
-			result.add(value);
+		for (const element of sets[index]!) {
+			result.add(element);
 		}
 	}
 

diff --git a/src/operations/xor.function.ts b/src/operations/xor.function.ts
@@ -12,15 +12,15 @@ export function xor<T>(...sets: ReadonlySet<T>[]): ReadonlySet<T>;
  */
 export function xor<T, S extends ReadonlySet<T>>(...sets: S[]): S {
 	const result = new Set<T>(sets[0]);
-	const reusedValues = new Set<T>();
+	const reusedElements = new Set<T>();
 
 	for (let index = 1; index < sets.length; index++) {
-		for (const value of sets[index]!) {
-			if (result.has(value)) {
-				result.delete(value);
-				reusedValues.add(value);
-			} else if (!reusedValues.has(value)) {
-				result.add(value);
+		for (const element of sets[index]!) {
+			if (result.has(element)) {
+				result.delete(element);
+				reusedElements.add(element);
+			} else if (!reusedElements.has(element)) {
+				result.add(element);
 			}
 		}
 	}

diff --git a/src/ordering/sort.function.ts b/src/ordering/sort.function.ts
@@ -6,7 +6,7 @@ export function sort<T>(set: ReadonlySet<T>, compareFunction?: (a: T, b: T) => n
  * of Set sort does not modify the original Set.
  *
  * Instead, it returns a new sorted Set
- * with the same values contained in the original.
+ * with the same elements contained in the original.
  */
 export function sort<T, S extends ReadonlySet<T>>(set: S, compareFunction?: (a: T, b: T) => number): S {
 	return new Set<T>(Array.from(set).sort(compareFunction)) as ReadonlySet<T> as S;