happy-rusty 1.9.2 → 1.10.0

package/dist/main.mjs

@@ -21,7 +21,7 @@
 *
 * @internal
 */
-const OptionKindSymbol = /* @__PURE__ */ Symbol("Option kind");
+const OptionKindSymbol = /*#__PURE__*/ Symbol("Option kind");
 //#endregion
 //#region src/core/option/guards.ts
 /**
@@ -66,7 +66,7 @@ function isOption(o) {
 *
 * @internal
 */
-const ResultKindSymbol = /* @__PURE__ */ Symbol("Result kind");
+const ResultKindSymbol = /*#__PURE__*/ Symbol("Result kind");
 //#endregion
 //#region src/core/result/guards.ts
 /**
@@ -101,8 +101,8 @@ function isResult(r) {
 * - `Err<T, E>(error)` - Creates a failed Result
 * - `None` interface - Type overrides for better type inference
 */
-const ASYNC_TRUE$1 = /* @__PURE__ */ Promise.resolve(true);
-const ASYNC_FALSE$1 = /* @__PURE__ */ Promise.resolve(false);
+const ASYNC_TRUE$1 = /*#__PURE__*/ Promise.resolve(true);
+const ASYNC_FALSE$1 = /*#__PURE__*/ Promise.resolve(false);
 /**
 * Creates an `Option<T>` representing the presence of a value.
 * This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.
@@ -263,7 +263,7 @@ function Some(value) {
 * const name = None.unwrapOr('Anonymous'); // 'Anonymous'
 * ```
 */
-const None = /* @__PURE__ */ Object.freeze({
+const None = /*#__PURE__*/ Object.freeze({
 	[Symbol.toStringTag]: "Option",
 	[OptionKindSymbol]: "None",
 	*[Symbol.iterator]() {},
@@ -402,7 +402,7 @@ const None = /* @__PURE__ */ Object.freeze({
 * }
 * ```
 */
-const ASYNC_NONE = /* @__PURE__ */ Promise.resolve(None);
+const ASYNC_NONE = /*#__PURE__*/ Promise.resolve(None);
 function Ok(value) {
 	const ok = Object.freeze({
 		[Symbol.toStringTag]: "Result",
@@ -802,7 +802,7 @@ async function tryAsyncOption(task, ...args) {
 * const value: boolean = RESULT_TRUE.intoOk(); // Safe extraction
 * ```
 */
-const RESULT_TRUE = /* @__PURE__ */ Ok(true);
+const RESULT_TRUE = /*#__PURE__*/ Ok(true);
 /**
 * Result constant for `false`.
 * Can be used anywhere due to immutability.
@@ -817,7 +817,7 @@ const RESULT_TRUE = /* @__PURE__ */ Ok(true);
 * const value: boolean = RESULT_FALSE.intoOk(); // Safe extraction
 * ```
 */
-const RESULT_FALSE = /* @__PURE__ */ Ok(false);
+const RESULT_FALSE = /*#__PURE__*/ Ok(false);
 /**
 * Result constant for `0`.
 * Can be used anywhere due to immutability.
@@ -832,7 +832,7 @@ const RESULT_FALSE = /* @__PURE__ */ Ok(false);
 * const value: number = RESULT_ZERO.intoOk(); // Safe extraction
 * ```
 */
-const RESULT_ZERO = /* @__PURE__ */ Ok(0);
+const RESULT_ZERO = /*#__PURE__*/ Ok(0);
 /**
 * Result constant for `void` or `()`.
 * Can be used anywhere due to immutability.
@@ -847,7 +847,7 @@ const RESULT_ZERO = /* @__PURE__ */ Ok(0);
 * RESULT_VOID.intoOk(); // Safe extraction (returns undefined)
 * ```
 */
-const RESULT_VOID = /* @__PURE__ */ Ok();
+const RESULT_VOID = /*#__PURE__*/ Ok();
 //#endregion
 //#region src/core/result/extensions.ts
 /**
@@ -934,7 +934,7 @@ async function tryAsyncResult(task, ...args) {
 *
 * @internal
 */
-const ControlFlowKindSymbol = /* @__PURE__ */ Symbol("ControlFlow kind");
+const ControlFlowKindSymbol = /*#__PURE__*/ Symbol("ControlFlow kind");
 //#endregion
 //#region src/std/ops/control_flow.ts
 /**
@@ -1147,8 +1147,8 @@ function isControlFlow(cf) {
 * Supports rendezvous (capacity=0) for synchronous handoff between sender and receiver.
 *
 */
-const ASYNC_TRUE = /* @__PURE__ */ Promise.resolve(true);
-const ASYNC_FALSE = /* @__PURE__ */ Promise.resolve(false);
+const ASYNC_TRUE = /*#__PURE__*/ Promise.resolve(true);
+const ASYNC_FALSE = /*#__PURE__*/ Promise.resolve(false);
 /**
 * Creates a new MPMC channel with the specified capacity.
 *
@@ -2214,6 +2214,17 @@ function RwLock(value) {
 				if (released) return;
 				released = true;
 				releaseWrite();
+			},
+			downgrade() {
+				if (released) throw new Error("RwLockWriteGuard has been released");
+				released = true;
+				writer = false;
+				readers = 1;
+				while (readWaitQueue.length > 0) {
+					readers++;
+					readWaitQueue.shift()();
+				}
+				return createReadGuard();
 			}
 		});
 	}
@@ -2302,6 +2313,119 @@ function RwLock(value) {
 	});
 }
 //#endregion
-export { ASYNC_NONE, Break, Channel, Continue, Err, FnOnce, FnOnceAsync, Lazy, LazyAsync, Mutex, None, Ok, Once, OnceAsync, RESULT_FALSE, RESULT_TRUE, RESULT_VOID, RESULT_ZERO, RwLock, Some, isControlFlow, isOption, isResult, tryAsyncOption, tryAsyncResult, tryOption, tryResult };
+//#region src/std/sync/semaphore.ts
+/**
+* @module
+* Counting semaphore for limiting async concurrency.
+*
+* Inspired by [tokio's `Semaphore`](https://docs.rs/tokio/latest/tokio/sync/struct.Semaphore.html)
+* (Rust std does not include one). Unlike `Mutex<T>` which binds to a value,
+* `Semaphore` is a pure concurrency counter: it limits how many async
+* operations can run concurrently without protecting any data.
+*
+* **When to use `Semaphore` vs `Mutex<T>`:**
+* - Use `Mutex<T>` for exclusive access to a value (n=1, with data)
+* - Use `Semaphore` to limit concurrency to N (e.g. fetch rate limiting,
+*   connection pools, task queues)
+*
+* `Semaphore(1)` behaves like a `Mutex` without a value (a binary semaphore),
+* but `Mutex<T>` is preferred when you need to protect a value since the
+* guard provides typed access via `value`.
+*/
+/**
+* Creates a new `Semaphore` with the given capacity.
+*
+* @param permits - The maximum number of concurrent operations allowed.
+*                  Must be a non-negative integer. Use `0` to disallow any
+*                  concurrent acquire (acquire will wait forever).
+* @returns A new `Semaphore` instance.
+* @throws {RangeError} If `permits` is negative or not an integer.
+* @example
+* ```ts
+* // Limit to 5 concurrent operations
+* const sem = Semaphore(5);
+*
+* // Binary semaphore (equivalent to a value-less Mutex)
+* const binary = Semaphore(1);
+* ```
+*
+* @example
+* ```ts
+* // Task queue: process 2 jobs at a time
+* const sem = Semaphore(2);
+*
+* async function processJob(job: Job) {
+*     return sem.withPermit(async () => {
+*         return await runJob(job);
+*     });
+* }
+*
+* await Promise.all(jobs.map(processJob));
+* ```
+*/
+function Semaphore(permits) {
+	if (!Number.isInteger(permits) || permits < 0) throw new RangeError(`Semaphore capacity must be a non-negative integer, got ${permits}`);
+	const capacity = permits;
+	let available = permits;
+	const waitQueue = [];
+	function releasePermit() {
+		if (waitQueue.length > 0) waitQueue.shift()();
+		else available++;
+	}
+	function createPermit() {
+		let released = false;
+		return Object.freeze({
+			[Symbol.toStringTag]: "SemaphorePermit",
+			toString() {
+				return released ? "SemaphorePermit(<released>)" : "SemaphorePermit";
+			},
+			release() {
+				if (released) return;
+				released = true;
+				releasePermit();
+			}
+		});
+	}
+	function acquire() {
+		if (available > 0) {
+			available--;
+			return Promise.resolve(createPermit());
+		}
+		return new Promise((resolve) => {
+			waitQueue.push(() => {
+				resolve(createPermit());
+			});
+		});
+	}
+	function tryAcquire() {
+		if (available > 0) {
+			available--;
+			return Some(createPermit());
+		}
+		return None;
+	}
+	return Object.freeze({
+		[Symbol.toStringTag]: "Semaphore",
+		toString() {
+			return `Semaphore(${available}/${capacity})`;
+		},
+		capacity,
+		async withPermit(fn) {
+			const permit = await acquire();
+			try {
+				return await fn();
+			} finally {
+				permit.release();
+			}
+		},
+		acquire,
+		tryAcquire,
+		availablePermits() {
+			return available;
+		}
+	});
+}
+//#endregion
+export { ASYNC_NONE, Break, Channel, Continue, Err, FnOnce, FnOnceAsync, Lazy, LazyAsync, Mutex, None, Ok, Once, OnceAsync, RESULT_FALSE, RESULT_TRUE, RESULT_VOID, RESULT_ZERO, RwLock, Semaphore, Some, isControlFlow, isOption, isResult, tryAsyncOption, tryAsyncResult, tryOption, tryResult };
 
 //# sourceMappingURL=main.mjs.map