polish

Author: kt3k

collections/chunk_test.ts

@@ -15,7 +15,7 @@ function chunkTest<I>(
 const testArray = [1, 2, 3, 4, 5, 6];
 
 Deno.test({
-  name: "chunk() handles no mutation",
+  name: "chunk() does not mutate the input",
   fn() {
     const array = [1, 2, 3, 4];
     chunk(array, 2);
@@ -121,94 +121,6 @@ Deno.test({
   },
 });
 
-Deno.test("chunk() does not mutate the input", () => {
-  const array = [1, 2, 3, 4];
-  chunk(array, 2);
-  assertEquals(array, [1, 2, 3, 4], "Input array should not be mutated");
-});
-
-Deno.test("chunk() throws on non naturals", () => {
-  assertThrows(
-    () => chunk([], +.5),
-    RangeError,
-    "Expected size to be an integer greater than 0 but found 0.5",
-  );
-  assertThrows(
-    () => chunk([], -4.7),
-    RangeError,
-    "Expected size to be an integer greater than 0 but found -4.7",
-  );
-  assertThrows(
-    () => chunk([], -2),
-    RangeError,
-    "Expected size to be an integer greater than 0 but found -2",
-  );
-  assertThrows(
-    () => chunk([], +0),
-    RangeError,
-    "Expected size to be an integer greater than 0 but found 0",
-  );
-  assertThrows(
-    () => chunk([], -0),
-    RangeError,
-    "Expected size to be an integer greater than 0 but found 0",
-  );
-});
-
-Deno.test("chunk() returns empty array when input is empty", () => {
-  const actual = chunk([], 1);
-  assertEquals(actual, [], "Empty input should return empty array");
-});
-
-Deno.test({
-  name: "chunk() handles single element chunks",
-  fn() {
-    assertEquals(chunk([1, 2, 3, 4, 5, 6], 1), [[1], [2], [3], [4], [5], [6]]);
-    assertEquals(chunk(["foo"], 1), [["foo"]]);
-    assertEquals(chunk([null], 1), [[null]]);
-    assertEquals(chunk([undefined], 1), [[undefined]]);
-  },
-});
-
-Deno.test("chunk() handles n chunks fitting", () => {
-  assertEquals(
-    chunk([1, 2, 3, 4, 5, 6], 2),
-    [[1, 2], [3, 4], [5, 6]],
-    "size=2",
-  );
-  assertEquals(chunk([1, 2, 3, 4, 5, 6], 3), [[1, 2, 3], [4, 5, 6]], "size=3");
-});
-
-Deno.test("handles n chunks not fitting", () => {
-  assertEquals(
-    chunk([1, 2, 3, 4, 5, 6], 4),
-    [[1, 2, 3, 4], [5, 6]],
-    "size 4 with 6 elements should return 2 chunks with 4 and 2 elements",
-  );
-  assertEquals(
-    chunk([1, 2, 3, 4, 5, 6], 5),
-    [[1, 2, 3, 4, 5], [6]],
-    "size 5 with 6 elements should return 2 chunks with 5 and 1 elements",
-  );
-});
-
-Deno.test("chunk() handles n chunks larger than input length", () => {
-  assertEquals(
-    chunk([1, 2, 3, 4, 5, 6], 10),
-    [[1, 2, 3, 4, 5, 6]],
-  );
-});
-
-Deno.test({
-  name: "chunk() handles chunks equal to length",
-  fn() {
-    assertEquals(
-      chunk([1, 2, 3, 4, 5, 6], 6),
-      [[1, 2, 3, 4, 5, 6]],
-    );
-  },
-});
-
 Deno.test("chunk() handles a generator", () => {
   function* gen() {
     yield "a";

collections/drop_while.ts

@@ -15,7 +15,7 @@
  *
  * @example Basic usage
  * ```ts
- * import { dropWhile } from "@std/collections/unstable-drop-while";
+ * import { dropWhile } from "@std/collections/drop-while";
  * import { assertEquals } from "@std/assert";
  *
  * const numbers = [3, 2, 5, 2, 5];

collections/drop_while_test.ts

@@ -84,13 +84,13 @@ Deno.test("dropWhile() handles a generator", () => {
   assertEquals(actual, [4, 5, 6]);
 });
 
-Deno.test("(unstable) dropWhile() handles a Set", () => {
+Deno.test("dropWhile() handles a Set", () => {
   const set = new Set([1, 2, 3, 4, 5, 6]);
   const actual = dropWhile(set, (i) => i !== 4);
   assertEquals(actual, [4, 5, 6]);
 });
 
-Deno.test("(unstable) dropWhile() handles a Map", () => {
+Deno.test("dropWhile() handles a Map", () => {
   const map = new Map([
     ["a", 1],
     ["b", 2],

collections/intersect_test.ts

@@ -142,64 +142,6 @@ Deno.test({
   },
 });
 
-Deno.test("intersect() doesn't mutate the input", () => {
-  const arrayA = [1, 2, 3];
-  const arrayB = [3, 4, 5];
-  intersect(arrayA, arrayB);
-  assertEquals(arrayA, [1, 2, 3]);
-  assertEquals(arrayB, [3, 4, 5]);
-});
-
-Deno.test("intersect() returns empty array when one side is empty", () => {
-  const firstEmpty = intersect([], [1, 2, 3]);
-  const secondEmpty = intersect([1, 2, 3], []);
-  assertEquals(firstEmpty, []);
-  assertEquals(secondEmpty, []);
-});
-
-Deno.test("intersect() handles one or more items in intersection", () => {
-  const one = intersect(["a", "b"], ["b", "c"]);
-  const two = intersect(["a", "b", "c", "d"], ["c", "d", "e", "f"]);
-  assertEquals(one, ["b"]);
-  assertEquals(two, ["c", "d"]);
-});
-
-Deno.test("intersect() removes duplicates", () => {
-  const duplicates = intersect(["a", "b", "c", "b"], ["b", "c"]);
-  const moreDuplicates = intersect(["a", "b"], ["b", "b", "c", "c"]);
-  assertEquals(duplicates, ["b", "c"]);
-  assertEquals(moreDuplicates, ["b"]);
-});
-
-Deno.test("intersect() handles more than two inputs", () => {
-  assertEquals(
-    intersect(
-      ["a", "b"],
-      ["b", "c"],
-      ["s", "b"],
-      ["b", "b"],
-    ),
-    ["b"],
-  );
-  assertEquals(
-    intersect(
-      [1],
-      [1],
-      [2],
-    ),
-    [],
-  );
-
-  assertEquals(
-    intersect(
-      [true, false],
-      [true, false],
-      [true],
-    ),
-    [true],
-  );
-});
-
 // If you are using sets using {@linkcode Set.prototype.intersection} directly is more efficient.
 Deno.test("intersect() handles sets", () => {
   const a = new Set([1, 2, 3, 4]);
@@ -233,7 +175,7 @@ Deno.test("intersect() handles iterables with no mutation", () => {
   assert(b.has(3));
 });
 
-Deno.test("(unstable) intersect() handles generators", () => {
+Deno.test("intersect() handles generators", () => {
   function* gen() {
     yield 1;
     yield 2;

collections/without_all.ts

@@ -4,6 +4,9 @@
 /**
  * Returns an array excluding all given values from an iterable.
  *
+ * Note: If both inputs are {@linkcode Set}s, and you want the difference as a
+ * {@linkcode Set}, you could use {@linkcode Set.prototype.difference} instead.
+ *
  * @typeParam T The type of the elements in the iterable.
  *
  * @param iterable The iterable to exclude values from.
@@ -12,10 +15,6 @@
  * @returns An array containing all elements from iterables except the
  * ones that are in the values iterable.
  *
- * @remarks
- * If both inputs are a {@linkcode Set}, and you want the difference as a
- * {@linkcode Set}, you could use {@linkcode Set.prototype.difference} instead.
- *
  * @example Basic usage
  * ```ts
  * import { withoutAll } from "@std/collections/without-all";

collections/without_all_test.ts

@@ -63,7 +63,7 @@ Deno.test({
   },
 });
 
-Deno.test("(unstable) withoutAll() handles generators", () => {
+Deno.test("withoutAll() handles generators", () => {
   function* genInput() {
     yield 1;
     yield 2;