happy-rusty 1.5.0 → 1.6.1

package/dist/main.cjs

@@ -1,7 +1,9 @@
 'use strict';
 
-const OptionKindSymbol = Symbol("Option kind");
-const ResultKindSymbol = Symbol("Result kind");
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const OptionKindSymbol = /* @__PURE__ */ Symbol("Option kind");
+const ResultKindSymbol = /* @__PURE__ */ Symbol("Result kind");
 
 function isOption(o) {
   return o != null && typeof o === "object" && OptionKindSymbol in o;
@@ -11,7 +13,7 @@ function isResult(r) {
 }
 
 function Some(value) {
-  const some = {
+  const some = Object.freeze({
     [Symbol.toStringTag]: "Option",
     [OptionKindSymbol]: "Some",
     isSome() {
@@ -26,6 +28,12 @@ function Some(value) {
     isSomeAndAsync(predicate) {
       return predicate(value);
     },
+    isNoneOr(predicate) {
+      return predicate(value);
+    },
+    isNoneOrAsync(predicate) {
+      return predicate(value);
+    },
     expect(_msg) {
       return value;
     },
@@ -48,17 +56,15 @@ function Some(value) {
       return Ok(value);
     },
     transpose() {
-      const r = value;
-      assertResult(r);
-      return r.isOk() ? Ok(Some(r.unwrap())) : Err(r.unwrapErr());
+      assertResult(value);
+      return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());
     },
     filter(predicate) {
       return predicate(value) ? some : None;
     },
     flatten() {
-      const o = value;
-      assertOption(o);
-      return o;
+      assertOption(value);
+      return value;
     },
     map(fn) {
       return Some(fn(value));
@@ -80,7 +86,7 @@ function Some(value) {
     unzip() {
       const tuple = value;
       if (!Array.isArray(tuple) || tuple.length !== 2) {
-        throw new TypeError("Unzip format is incorrect.");
+        throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${Array.isArray(tuple) ? `array with ${tuple.length} elements` : typeof tuple}.`);
       }
       const [a, b] = tuple;
       return [Some(a), Some(b)];
@@ -119,7 +125,7 @@ function Some(value) {
     toString() {
       return `Some(${value})`;
     }
-  };
+  });
   return some;
 }
 const None = Object.freeze({
@@ -137,11 +143,17 @@ const None = Object.freeze({
   isSomeAndAsync(_predicate) {
     return Promise.resolve(false);
   },
+  isNoneOr(_predicate) {
+    return true;
+  },
+  isNoneOrAsync(_predicate) {
+    return Promise.resolve(true);
+  },
   expect(msg) {
     throw new TypeError(msg);
   },
   unwrap() {
-    throw new TypeError("Called `Option::unwrap()` on a `None` value");
+    throw new TypeError("Option::unwrap() called on a `None` value.");
   },
   unwrapOr(defaultValue) {
     return defaultValue;
@@ -220,7 +232,7 @@ const None = Object.freeze({
   }
 });
 function Ok(value) {
-  const ok = {
+  const ok = Object.freeze({
     [Symbol.toStringTag]: "Result",
     [ResultKindSymbol]: "Ok",
     isOk() {
@@ -260,7 +272,7 @@ function Ok(value) {
       throw new TypeError(`${msg}: ${value}`);
     },
     unwrapErr() {
-      throw new TypeError("Called `Result::unwrapErr()` on an `Ok` value");
+      throw new TypeError("Result::unwrapErr() called on an `Ok` value.");
     },
     ok() {
       return Some(value);
@@ -269,9 +281,8 @@ function Ok(value) {
       return None;
     },
     transpose() {
-      const o = value;
-      assertOption(o);
-      return o.isSome() ? Some(Ok(o.unwrap())) : None;
+      assertOption(value);
+      return value.isSome() ? Some(Ok(value.unwrap())) : None;
     },
     map(fn) {
       return Ok(fn(value));
@@ -286,9 +297,8 @@ function Ok(value) {
       return fn(value);
     },
     flatten() {
-      const r = value;
-      assertResult(r);
-      return r;
+      assertResult(value);
+      return value;
     },
     and(other) {
       assertResult(other);
@@ -324,16 +334,16 @@ function Ok(value) {
       return ok;
     },
     asErr() {
-      throw new TypeError("Called `Result::asErr()` on an `Ok` value");
+      throw new TypeError("Result::asErr() called on an `Ok` value.");
     },
     toString() {
       return `Ok(${value})`;
     }
-  };
+  });
   return ok;
 }
 function Err(error) {
-  const err = {
+  const err = Object.freeze({
     [Symbol.toStringTag]: "Result",
     [ResultKindSymbol]: "Err",
     isOk() {
@@ -358,7 +368,7 @@ function Err(error) {
       throw new TypeError(`${msg}: ${error}`);
     },
     unwrap() {
-      throw new TypeError("Called `Result::unwrap()` on an `Err` value");
+      throw new TypeError("Result::unwrap() called on an `Err` value.");
     },
     unwrapOr(defaultValue) {
       return defaultValue;
@@ -430,7 +440,7 @@ function Err(error) {
       return other.isErr() && other.unwrapErr() === error;
     },
     asOk() {
-      throw new TypeError("Called `Result::asOk()` on an `Err` value");
+      throw new TypeError("Result::asOk() called on an `Err` value.");
     },
     asErr() {
       return err;
@@ -438,17 +448,33 @@ function Err(error) {
     toString() {
       return `Err(${error})`;
     }
-  };
+  });
   return err;
 }
+function safeStringify(value) {
+  try {
+    if (value === null) {
+      return "null";
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    if (typeof value === "object") {
+      return Object.prototype.toString.call(value);
+    }
+    return String(value);
+  } catch {
+    return "[unable to stringify]";
+  }
+}
 function assertOption(o) {
   if (!isOption(o)) {
-    throw new TypeError(`This(${o}) is not an Option`);
+    throw new TypeError(`Expected an Option, but received: ${safeStringify(o)}.`);
   }
 }
 function assertResult(r) {
   if (!isResult(r)) {
-    throw new TypeError(`This(${r}) is not a Result`);
+    throw new TypeError(`Expected a Result, but received: ${safeStringify(r)}.`);
   }
 }
 
@@ -457,22 +483,346 @@ const RESULT_FALSE = Ok(false);
 const RESULT_ZERO = Ok(0);
 const RESULT_VOID = Ok();
 
-function promiseToAsyncResult(p) {
-  return p.then((x) => {
-    return Ok(x);
-  }).catch((err) => {
+async function promiseToAsyncResult(p) {
+  try {
+    return Ok(await p);
+  } catch (err) {
     return Err(err);
+  }
+}
+
+const ControlFlowKindSymbol = /* @__PURE__ */ Symbol("ControlFlow kind");
+
+function Break(value) {
+  const brk = Object.freeze({
+    [Symbol.toStringTag]: "ControlFlow",
+    [ControlFlowKindSymbol]: "Break",
+    isBreak() {
+      return true;
+    },
+    isContinue() {
+      return false;
+    },
+    breakValue() {
+      return Some(value);
+    },
+    continueValue() {
+      return None;
+    },
+    mapBreak(fn) {
+      return Break(fn(value));
+    },
+    mapContinue(_fn) {
+      return brk;
+    },
+    breakOk() {
+      return Ok(value);
+    },
+    continueOk() {
+      return Err(value);
+    },
+    toString() {
+      return `Break(${value})`;
+    }
+  });
+  return brk;
+}
+function Continue(value) {
+  const cont = Object.freeze({
+    [Symbol.toStringTag]: "ControlFlow",
+    [ControlFlowKindSymbol]: "Continue",
+    isBreak() {
+      return false;
+    },
+    isContinue() {
+      return true;
+    },
+    breakValue() {
+      return None;
+    },
+    continueValue() {
+      return Some(value);
+    },
+    mapBreak(_fn) {
+      return cont;
+    },
+    mapContinue(fn) {
+      return Continue(fn(value));
+    },
+    breakOk() {
+      return Err(value);
+    },
+    continueOk() {
+      return Ok(value);
+    },
+    toString() {
+      return `Continue(${value})`;
+    }
+  });
+  return cont;
+}
+
+function isControlFlow(cf) {
+  return cf != null && typeof cf === "object" && ControlFlowKindSymbol in cf;
+}
+
+function Lazy(fn) {
+  let value;
+  let initialized = false;
+  return Object.freeze({
+    [Symbol.toStringTag]: "Lazy",
+    force() {
+      if (!initialized) {
+        value = fn();
+        initialized = true;
+      }
+      return value;
+    },
+    get() {
+      return initialized ? Some(value) : None;
+    },
+    isInitialized() {
+      return initialized;
+    },
+    toString() {
+      return initialized ? `Lazy(${value})` : "Lazy(<uninitialized>)";
+    }
+  });
+}
+function LazyAsync(fn) {
+  let value;
+  let initialized = false;
+  let pendingPromise;
+  return Object.freeze({
+    [Symbol.toStringTag]: "LazyAsync",
+    async force() {
+      if (initialized) {
+        return value;
+      }
+      if (pendingPromise) {
+        return pendingPromise;
+      }
+      pendingPromise = (async () => {
+        try {
+          const result = await fn();
+          value = result;
+          initialized = true;
+          return result;
+        } finally {
+          pendingPromise = void 0;
+        }
+      })();
+      return pendingPromise;
+    },
+    get() {
+      return initialized ? Some(value) : None;
+    },
+    isInitialized() {
+      return initialized;
+    },
+    toString() {
+      return initialized ? `LazyAsync(${value})` : "LazyAsync(<uninitialized>)";
+    }
+  });
+}
+
+function Mutex(value) {
+  let currentValue = value;
+  let locked = false;
+  const waitQueue = [];
+  function unlock() {
+    if (waitQueue.length > 0) {
+      const next = waitQueue.shift();
+      next();
+    } else {
+      locked = false;
+    }
+  }
+  function createGuard() {
+    let released = false;
+    return Object.freeze({
+      [Symbol.toStringTag]: "MutexGuard",
+      get value() {
+        if (released) {
+          throw new Error("MutexGuard has been released.");
+        }
+        return currentValue;
+      },
+      set value(newValue) {
+        if (released) {
+          throw new Error("MutexGuard has been released.");
+        }
+        currentValue = newValue;
+      },
+      unlock() {
+        if (released) {
+          return;
+        }
+        released = true;
+        unlock();
+      },
+      toString() {
+        if (released) {
+          return "MutexGuard(<released>)";
+        }
+        return `MutexGuard(${currentValue})`;
+      }
+    });
+  }
+  function lock() {
+    if (!locked) {
+      locked = true;
+      return Promise.resolve(createGuard());
+    }
+    return new Promise((resolve) => {
+      waitQueue.push(() => {
+        resolve(createGuard());
+      });
+    });
+  }
+  return Object.freeze({
+    [Symbol.toStringTag]: "Mutex",
+    async withLock(fn) {
+      const guard = await lock();
+      try {
+        return await fn(guard.value);
+      } finally {
+        guard.unlock();
+      }
+    },
+    lock,
+    tryLock() {
+      if (locked) {
+        return None;
+      }
+      locked = true;
+      return Some(createGuard());
+    },
+    isLocked() {
+      return locked;
+    },
+    toString() {
+      return locked ? "Mutex(<locked>)" : "Mutex(<unlocked>)";
+    }
+  });
+}
+
+function Once() {
+  let value;
+  let initialized = false;
+  let pendingPromise;
+  return Object.freeze({
+    [Symbol.toStringTag]: "Once",
+    get() {
+      return initialized ? Some(value) : None;
+    },
+    set(newValue) {
+      if (initialized) {
+        return Err(newValue);
+      }
+      value = newValue;
+      initialized = true;
+      return Ok(void 0);
+    },
+    getOrInit(fn) {
+      if (!initialized) {
+        value = fn();
+        initialized = true;
+      }
+      return value;
+    },
+    async getOrInitAsync(fn) {
+      if (initialized) {
+        return value;
+      }
+      if (pendingPromise) {
+        return pendingPromise;
+      }
+      pendingPromise = (async () => {
+        try {
+          const result = await fn();
+          value = result;
+          initialized = true;
+          return result;
+        } finally {
+          pendingPromise = void 0;
+        }
+      })();
+      return pendingPromise;
+    },
+    getOrTryInit(fn) {
+      if (initialized) {
+        return Ok(value);
+      }
+      const result = fn();
+      if (result.isOk()) {
+        value = result.unwrap();
+        initialized = true;
+      }
+      return result;
+    },
+    async getOrTryInitAsync(fn) {
+      if (initialized) {
+        return Ok(value);
+      }
+      if (pendingPromise) {
+        try {
+          await pendingPromise;
+          return Ok(value);
+        } catch {
+        }
+      }
+      pendingPromise = (async () => {
+        const result = await fn();
+        if (result.isOk()) {
+          value = result.unwrap();
+          initialized = true;
+          return value;
+        }
+        throw result;
+      })();
+      try {
+        const resultValue = await pendingPromise;
+        return Ok(resultValue);
+      } catch (errResult) {
+        return errResult;
+      } finally {
+        pendingPromise = void 0;
+      }
+    },
+    take() {
+      if (!initialized) {
+        return None;
+      }
+      const taken = value;
+      value = void 0;
+      initialized = false;
+      return Some(taken);
+    },
+    isInitialized() {
+      return initialized;
+    },
+    toString() {
+      return initialized ? `Once(${value})` : "Once(<uninitialized>)";
+    }
   });
 }
 
+exports.Break = Break;
+exports.Continue = Continue;
 exports.Err = Err;
+exports.Lazy = Lazy;
+exports.LazyAsync = LazyAsync;
+exports.Mutex = Mutex;
 exports.None = None;
 exports.Ok = Ok;
+exports.Once = Once;
 exports.RESULT_FALSE = RESULT_FALSE;
 exports.RESULT_TRUE = RESULT_TRUE;
 exports.RESULT_VOID = RESULT_VOID;
 exports.RESULT_ZERO = RESULT_ZERO;
 exports.Some = Some;
+exports.isControlFlow = isControlFlow;
 exports.isOption = isOption;
 exports.isResult = isResult;
 exports.promiseToAsyncResult = promiseToAsyncResult;