@monstermann/set 0.1.1 → 0.3.0

package/dist/Set/union.mjs

@@ -2,36 +2,46 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/union.ts
 /**
+* # union
+*
 * ```ts
-* function Set.union(target, source)
+* function Set.union<T, U>(
+*     target: Set<T>,
+*     source: Set<U>,
+* ): Set<T | U>
 * ```
 *
-* Example
+* Returns a set containing all values from both sets.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.union(Set.create([1, 2]), Set.create([2, 3, 4])); // Set([1, 2, 3, 4])
 * Set.union(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2]), Set.union(Set.create([2, 3, 4]))); // Set([1, 2, 3, 4])
 * pipe(Set.create([1, 2]), Set.union(Set.create([3, 4]))); // Set([1, 2, 3, 4])
 * ```
+*
 */
 const union = dfdlT((target, source) => {
 	if (source.size === 0) return target;
 	if (target.size === 0) return source;
+	let result;
 	for (const element of source) if (!target.has(element)) {
-		const result = /* @__PURE__ */ new Set();
-		for (const a of target) result.add(a);
-		for (const b of source) result.add(b);
-		return result;
+		if (result === void 0) {
+			result = /* @__PURE__ */ new Set();
+			for (const a of target) result.add(a);
+		}
+		result.add(element);
 	}
-	return target;
+	return result ?? target;
 }, 2);
 
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@monstermann/set",
     "type": "module",
-    "version": "0.1.1",
+    "version": "0.3.0",
     "description": "Functional utilities for sets.",
     "author": "Michael Ostermann <michaelostermann@me.com>",
     "license": "MIT",
@@ -34,6 +34,6 @@
     },
     "dependencies": {
         "@monstermann/dfdl": "^0.1.0",
-        "@monstermann/remmi": "^0.0.0"
+        "@monstermann/remmi": "^0.1.0"
     }
 }

package/dist/Set/addOr.d.mts

@@ -1,28 +0,0 @@
-//#region src/Set/addOr.d.ts
-/**
- * ```ts
- * function Set.addOr(target, value, or)
- * ```
- *
- * Example
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * Set.addOr(Set.create([1, 2]), 3, null); // Set([1, 2, 3])
- * Set.addOr(Set.create([1, 2]), 2, null); // null
- * ```
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * pipe(Set.create([1, 2]), Set.addOr(3, null)); // Set([1, 2, 3])
- * pipe(Set.create([1, 2]), Set.addOr(2, null)); // null
- * ```
- */
-declare const addOr: {
-  <T, U>(value: NoInfer<T>, or: U): (target: ReadonlySet<T>) => Set<T> | U;
-  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, or: U): Set<T> | U;
-};
-//#endregion
-export { addOr };

package/dist/Set/addOr.mjs

@@ -1,34 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-import { cloneSet } from "@monstermann/remmi";
-
-//#region src/Set/addOr.ts
-/**
-* ```ts
-* function Set.addOr(target, value, or)
-* ```
-*
-* Example
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* Set.addOr(Set.create([1, 2]), 3, null); // Set([1, 2, 3])
-* Set.addOr(Set.create([1, 2]), 2, null); // null
-* ```
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* pipe(Set.create([1, 2]), Set.addOr(3, null)); // Set([1, 2, 3])
-* pipe(Set.create([1, 2]), Set.addOr(2, null)); // null
-* ```
-*/
-const addOr = dfdlT((target, value, or) => {
-	if (target.has(value)) return or;
-	const result = cloneSet(target);
-	result.add(value);
-	return result;
-}, 3);
-
-//#endregion
-export { addOr };

package/dist/Set/addOrElse.d.mts

@@ -1,35 +0,0 @@
-//#region src/Set/addOrElse.d.ts
-/**
- * ```ts
- * function Set.addOrElse(target, value, orElse)
- * ```
- *
- * Example
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * Set.addOrElse(Set.create([1, 2]), 3, (set) => set.size); // Set([1, 2, 3])
- * Set.addOrElse(Set.create([1, 2]), 2, (set) => set.size); // 2
- * ```
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * pipe(
- *     Set.create([1, 2]),
- *     Set.addOrElse(3, (set) => set.size),
- * ); // Set([1, 2, 3])
- *
- * pipe(
- *     Set.create([1, 2]),
- *     Set.addOrElse(2, (set) => set.size),
- * ); // 2
- * ```
- */
-declare const addOrElse: {
-  <T, U>(value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): (target: ReadonlySet<T>) => Set<T> | U;
-  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): Set<T> | U;
-};
-//#endregion
-export { addOrElse };

package/dist/Set/addOrElse.mjs

@@ -1,41 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-import { cloneSet } from "@monstermann/remmi";
-
-//#region src/Set/addOrElse.ts
-/**
-* ```ts
-* function Set.addOrElse(target, value, orElse)
-* ```
-*
-* Example
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* Set.addOrElse(Set.create([1, 2]), 3, (set) => set.size); // Set([1, 2, 3])
-* Set.addOrElse(Set.create([1, 2]), 2, (set) => set.size); // 2
-* ```
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* pipe(
-*     Set.create([1, 2]),
-*     Set.addOrElse(3, (set) => set.size),
-* ); // Set([1, 2, 3])
-*
-* pipe(
-*     Set.create([1, 2]),
-*     Set.addOrElse(2, (set) => set.size),
-* ); // 2
-* ```
-*/
-const addOrElse = dfdlT((target, value, orElse) => {
-	if (target.has(value)) return orElse(target);
-	const result = cloneSet(target);
-	result.add(value);
-	return result;
-}, 3);
-
-//#endregion
-export { addOrElse };

package/dist/Set/addOrThrow.d.mts

@@ -1,28 +0,0 @@
-//#region src/Set/addOrThrow.d.ts
-/**
- * ```ts
- * function Set.addOrThrow(target, value)
- * ```
- *
- * Example
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * Set.addOrThrow(Set.create([1, 2]), 3); // Set([1, 2, 3])
- * Set.addOrThrow(Set.create([1, 2]), 2); // throws FnError
- * ```
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * pipe(Set.create([1, 2]), Set.addOrThrow(3)); // Set([1, 2, 3])
- * pipe(Set.create([1, 2]), Set.addOrThrow(2)); // throws FnError
- * ```
- */
-declare const addOrThrow: {
-  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => Set<T>;
-  <T>(target: ReadonlySet<T>, value: NoInfer<T>): Set<T>;
-};
-//#endregion
-export { addOrThrow };

package/dist/Set/addOrThrow.mjs

@@ -1,34 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-import { cloneSet } from "@monstermann/remmi";
-
-//#region src/Set/addOrThrow.ts
-/**
-* ```ts
-* function Set.addOrThrow(target, value)
-* ```
-*
-* Example
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* Set.addOrThrow(Set.create([1, 2]), 3); // Set([1, 2, 3])
-* Set.addOrThrow(Set.create([1, 2]), 2); // throws FnError
-* ```
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* pipe(Set.create([1, 2]), Set.addOrThrow(3)); // Set([1, 2, 3])
-* pipe(Set.create([1, 2]), Set.addOrThrow(2)); // throws FnError
-* ```
-*/
-const addOrThrow = dfdlT((target, value) => {
-	if (target.has(value)) throw new Error("Set.addOrThrow: Value already exists.");
-	const result = cloneSet(target);
-	result.add(value);
-	return result;
-}, 2);
-
-//#endregion
-export { addOrThrow };

package/dist/Set/removeOr.d.mts

@@ -1,28 +0,0 @@
-//#region src/Set/removeOr.d.ts
-/**
- * ```ts
- * function Set.removeOr(target, value, or)
- * ```
- *
- * Example
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * Set.removeOr(Set.create([1, 2, 3]), 2, null); // Set([1, 3])
- * Set.removeOr(Set.create([1, 2, 3]), 4, null); // null
- * ```
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * pipe(Set.create([1, 2, 3]), Set.removeOr(2, null)); // Set([1, 3])
- * pipe(Set.create([1, 2, 3]), Set.removeOr(4, null)); // null
- * ```
- */
-declare const removeOr: {
-  <T, U>(value: NoInfer<T>, or: U): (target: ReadonlySet<T>) => Set<T> | U;
-  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, or: U): Set<T> | U;
-};
-//#endregion
-export { removeOr };

package/dist/Set/removeOr.mjs

@@ -1,34 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-import { cloneSet } from "@monstermann/remmi";
-
-//#region src/Set/removeOr.ts
-/**
-* ```ts
-* function Set.removeOr(target, value, or)
-* ```
-*
-* Example
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* Set.removeOr(Set.create([1, 2, 3]), 2, null); // Set([1, 3])
-* Set.removeOr(Set.create([1, 2, 3]), 4, null); // null
-* ```
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* pipe(Set.create([1, 2, 3]), Set.removeOr(2, null)); // Set([1, 3])
-* pipe(Set.create([1, 2, 3]), Set.removeOr(4, null)); // null
-* ```
-*/
-const removeOr = dfdlT((target, value, or) => {
-	if (!target.has(value)) return or;
-	const result = cloneSet(target);
-	result.delete(value);
-	return result;
-}, 3);
-
-//#endregion
-export { removeOr };

package/dist/Set/removeOrElse.d.mts

@@ -1,35 +0,0 @@
-//#region src/Set/removeOrElse.d.ts
-/**
- * ```ts
- * function Set.removeOrElse(target, value, orElse)
- * ```
- *
- * Example
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * Set.removeOrElse(Set.create([1, 2, 3]), 2, (set) => set.size); // Set([1, 3])
- * Set.removeOrElse(Set.create([1, 2, 3]), 4, (set) => set.size); // 3
- * ```
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * pipe(
- *     Set.create([1, 2, 3]),
- *     Set.removeOrElse(2, (set) => set.size),
- * ); // Set([1, 3])
- *
- * pipe(
- *     Set.create([1, 2, 3]),
- *     Set.removeOrElse(4, (set) => set.size),
- * ); // 3
- * ```
- */
-declare const removeOrElse: {
-  <T, U>(value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): (target: ReadonlySet<T>) => Set<T> | U;
-  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): Set<T> | U;
-};
-//#endregion
-export { removeOrElse };

package/dist/Set/removeOrElse.mjs

@@ -1,41 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-import { cloneSet } from "@monstermann/remmi";
-
-//#region src/Set/removeOrElse.ts
-/**
-* ```ts
-* function Set.removeOrElse(target, value, orElse)
-* ```
-*
-* Example
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* Set.removeOrElse(Set.create([1, 2, 3]), 2, (set) => set.size); // Set([1, 3])
-* Set.removeOrElse(Set.create([1, 2, 3]), 4, (set) => set.size); // 3
-* ```
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* pipe(
-*     Set.create([1, 2, 3]),
-*     Set.removeOrElse(2, (set) => set.size),
-* ); // Set([1, 3])
-*
-* pipe(
-*     Set.create([1, 2, 3]),
-*     Set.removeOrElse(4, (set) => set.size),
-* ); // 3
-* ```
-*/
-const removeOrElse = dfdlT((target, value, orElse) => {
-	if (!target.has(value)) return orElse(target);
-	const result = cloneSet(target);
-	result.delete(value);
-	return result;
-}, 3);
-
-//#endregion
-export { removeOrElse };

package/dist/Set/removeOrThrow.d.mts

@@ -1,28 +0,0 @@
-//#region src/Set/removeOrThrow.d.ts
-/**
- * ```ts
- * function Set.removeOrThrow(target, value)
- * ```
- *
- * Example
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * Set.removeOrThrow(Set.create([1, 2, 3]), 2); // Set([1, 3])
- * Set.removeOrThrow(Set.create([1, 2, 3]), 4); // throws FnError
- * ```
- *
- * ```ts
- * import { Set } from "@monstermann/set";
- *
- * pipe(Set.create([1, 2, 3]), Set.removeOrThrow(2)); // Set([1, 3])
- * pipe(Set.create([1, 2, 3]), Set.removeOrThrow(4)); // throws FnError
- * ```
- */
-declare const removeOrThrow: {
-  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => Set<T>;
-  <T>(target: ReadonlySet<T>, value: NoInfer<T>): Set<T>;
-};
-//#endregion
-export { removeOrThrow };

package/dist/Set/removeOrThrow.mjs

@@ -1,34 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-import { cloneSet } from "@monstermann/remmi";
-
-//#region src/Set/removeOrThrow.ts
-/**
-* ```ts
-* function Set.removeOrThrow(target, value)
-* ```
-*
-* Example
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* Set.removeOrThrow(Set.create([1, 2, 3]), 2); // Set([1, 3])
-* Set.removeOrThrow(Set.create([1, 2, 3]), 4); // throws FnError
-* ```
-*
-* ```ts
-* import { Set } from "@monstermann/set";
-*
-* pipe(Set.create([1, 2, 3]), Set.removeOrThrow(2)); // Set([1, 3])
-* pipe(Set.create([1, 2, 3]), Set.removeOrThrow(4)); // throws FnError
-* ```
-*/
-const removeOrThrow = dfdlT((target, value) => {
-	if (!target.has(value)) throw new Error("Set.removeOrThrow: Value does not exist.");
-	const result = cloneSet(target);
-	result.delete(value);
-	return result;
-}, 2);
-
-//#endregion
-export { removeOrThrow };