happy-rusty 1.1.1 → 1.2.0

package/dist/main.mjs

@@ -2,39 +2,66 @@ const optionKindSymbol = Symbol("Option kind");
 const resultKindSymbol = Symbol("Result kind");
 function Some(value) {
   const some = {
+    [Symbol.toStringTag]: "Option",
     [optionKindSymbol]: "Some",
-    isSome: () => true,
-    isNone: () => false,
-    isSomeAnd: (predicate) => predicate(value),
-    expect: (_msg) => value,
-    unwrap: () => value,
-    unwrapOr: (_defaultValue) => value,
-    unwrapOrElse: (_fn) => value,
-    okOr: (_error) => Ok(value),
-    okOrElse: (_err) => Ok(value),
-    transpose: () => {
+    isSome() {
+      return true;
+    },
+    isNone() {
+      return false;
+    },
+    isSomeAnd(predicate) {
+      return predicate(value);
+    },
+    expect(_msg) {
+      return value;
+    },
+    unwrap() {
+      return value;
+    },
+    unwrapOr(_defaultValue) {
+      return value;
+    },
+    unwrapOrElse(_fn) {
+      return value;
+    },
+    okOr(_error) {
+      return Ok(value);
+    },
+    okOrElse(_err) {
+      return Ok(value);
+    },
+    transpose() {
       const r = value;
       assertResult(r);
       return r.isOk() ? Ok(Some(r.unwrap())) : Err(r.unwrapErr());
     },
-    filter: (predicate) => predicate(value) ? some : None,
-    flatten: () => {
+    filter(predicate) {
+      return predicate(value) ? some : None;
+    },
+    flatten() {
       const o = value;
       assertOption(o);
       return o;
     },
-    map: (fn) => Some(fn(value)),
-    mapOr: (_defaultValue, fn) => fn(value),
-    mapOrElse: (_defaultFn, fn) => fn(value),
-    zip: (other) => {
+    map(fn) {
+      return Some(fn(value));
+    },
+    mapOr(_defaultValue, fn) {
+      return fn(value);
+    },
+    mapOrElse(_defaultFn, fn) {
+      return fn(value);
+    },
+    zip(other) {
       assertOption(other);
       return other.isSome() ? Some([value, other.unwrap()]) : None;
     },
-    zipWith: (other, fn) => {
+    zipWith(other, fn) {
       assertOption(other);
       return other.isSome() ? Some(fn(value, other.unwrap())) : None;
     },
-    unzip: () => {
+    unzip() {
       const tuple = value;
       if (!Array.isArray(tuple) || tuple.length !== 2) {
         throw new TypeError("Unzip format is incorrect.");
@@ -42,172 +69,321 @@ function Some(value) {
       const [a, b] = tuple;
       return [Some(a), Some(b)];
     },
-    and: (other) => {
+    and(other) {
       assertOption(other);
       return other;
     },
-    andThen: (fn) => fn(value),
-    or: (_other) => some,
-    orElse: (_fn) => some,
-    xor: (other) => {
+    andThen(fn) {
+      return fn(value);
+    },
+    or(_other) {
+      return some;
+    },
+    orElse(_fn) {
+      return some;
+    },
+    xor(other) {
       assertOption(other);
       return other.isSome() ? None : some;
     },
-    inspect: (fn) => {
+    inspect(fn) {
       fn(value);
       return some;
     },
-    eq: (other) => {
+    eq(other) {
       assertOption(other);
       return other.isSome() && other.unwrap() === value;
+    },
+    toString() {
+      return `Some(${value})`;
     }
   };
   return some;
 }
 const None = Object.freeze({
+  [Symbol.toStringTag]: "Option",
   [optionKindSymbol]: "None",
-  isSome: () => false,
-  isNone: () => true,
-  isSomeAnd: (_predicate) => false,
-  expect: (msg) => {
+  isSome() {
+    return false;
+  },
+  isNone() {
+    return true;
+  },
+  isSomeAnd(_predicate) {
+    return false;
+  },
+  expect(msg) {
     throw new TypeError(msg);
   },
-  unwrap: () => {
+  unwrap() {
     throw new TypeError("Called `Option::unwrap()` on a `None` value");
   },
-  unwrapOr: (defaultValue) => defaultValue,
-  unwrapOrElse: (fn) => fn(),
-  okOr: (error) => Err(error),
-  okOrElse: (err) => Err(err()),
-  transpose: () => Ok(None),
-  filter: (_predicate) => None,
-  flatten: () => None,
-  map: (_fn) => None,
-  mapOr: (defaultValue, _fn) => defaultValue,
-  mapOrElse: (defaultFn, _fn) => defaultFn(),
-  zip: (_other) => None,
-  zipWith: (_other, _fn) => None,
-  unzip: () => [None, None],
-  and: (_other) => None,
-  andThen: (_fn) => None,
-  or: (other) => {
+  unwrapOr(defaultValue) {
+    return defaultValue;
+  },
+  unwrapOrElse(fn) {
+    return fn();
+  },
+  okOr(error) {
+    return Err(error);
+  },
+  okOrElse(err) {
+    return Err(err());
+  },
+  transpose() {
+    return Ok(None);
+  },
+  filter(_predicate) {
+    return None;
+  },
+  flatten() {
+    return None;
+  },
+  map(_fn) {
+    return None;
+  },
+  mapOr(defaultValue, _fn) {
+    return defaultValue;
+  },
+  mapOrElse(defaultFn, _fn) {
+    return defaultFn();
+  },
+  zip(_other) {
+    return None;
+  },
+  zipWith(_other, _fn) {
+    return None;
+  },
+  unzip() {
+    return [None, None];
+  },
+  and(_other) {
+    return None;
+  },
+  andThen(_fn) {
+    return None;
+  },
+  or(other) {
     assertOption(other);
     return other;
   },
-  orElse: (fn) => fn(),
-  xor: (other) => {
+  orElse(fn) {
+    return fn();
+  },
+  xor(other) {
     assertOption(other);
     return other.isSome() ? other : None;
   },
-  inspect: (_fn) => None,
-  eq: (other) => {
+  inspect(_fn) {
+    return None;
+  },
+  eq(other) {
     assertOption(other);
     return other === None;
+  },
+  toString() {
+    return "None";
   }
 });
 function Ok(value) {
   const ok = {
+    [Symbol.toStringTag]: "Result",
     [resultKindSymbol]: "Ok",
-    isOk: () => true,
-    isErr: () => false,
-    isOkAnd: (predicate) => predicate(value),
-    isErrAnd: (_predicate) => false,
-    expect: (_msg) => value,
-    unwrap: () => value,
-    unwrapOr: (_defaultValue) => value,
-    unwrapOrElse: (_fn) => value,
-    expectErr: (msg) => {
+    isOk() {
+      return true;
+    },
+    isErr() {
+      return false;
+    },
+    isOkAnd(predicate) {
+      return predicate(value);
+    },
+    isErrAnd(_predicate) {
+      return false;
+    },
+    expect(_msg) {
+      return value;
+    },
+    unwrap() {
+      return value;
+    },
+    unwrapOr(_defaultValue) {
+      return value;
+    },
+    unwrapOrElse(_fn) {
+      return value;
+    },
+    expectErr(msg) {
       throw new TypeError(`${msg}: ${value}`);
     },
-    unwrapErr: () => {
+    unwrapErr() {
       throw new TypeError("Called `Result::unwrapErr()` on an `Ok` value");
     },
-    ok: () => Some(value),
-    err: () => None,
-    transpose: () => {
+    ok() {
+      return Some(value);
+    },
+    err() {
+      return None;
+    },
+    transpose() {
       const o = value;
       assertOption(o);
       return o.isSome() ? Some(Ok(o.unwrap())) : None;
     },
-    map: (fn) => Ok(fn(value)),
-    mapErr: (_fn) => Ok(value),
-    mapOr: (_defaultValue, fn) => fn(value),
-    mapOrElse: (_defaultFn, fn) => fn(value),
-    flatten: () => {
+    map(fn) {
+      return Ok(fn(value));
+    },
+    mapErr(_fn) {
+      return Ok(value);
+    },
+    mapOr(_defaultValue, fn) {
+      return fn(value);
+    },
+    mapOrElse(_defaultFn, fn) {
+      return fn(value);
+    },
+    flatten() {
       const r = value;
       assertResult(r);
       return r;
     },
-    and: (other) => {
+    and(other) {
       assertResult(other);
       return other;
     },
-    or: (_other) => ok,
-    andThen: (fn) => fn(value),
-    orElse: (_fn) => ok,
-    inspect: (fn) => {
+    or(_other) {
+      return ok;
+    },
+    andThen(fn) {
+      return fn(value);
+    },
+    orElse(_fn) {
+      return ok;
+    },
+    inspect(fn) {
       fn(value);
       return ok;
     },
-    inspectErr: (_fn) => ok,
-    eq: (other) => {
+    inspectErr(_fn) {
+      return ok;
+    },
+    eq(other) {
       assertResult(other);
       return other.isOk() && other.unwrap() === value;
+    },
+    asOk() {
+      return ok;
+    },
+    asErr() {
+      throw new TypeError("Called `Result::asErr()` on an `Ok` value");
+    },
+    toString() {
+      return `Ok(${value})`;
     }
   };
   return ok;
 }
 function Err(error) {
   const err = {
+    [Symbol.toStringTag]: "Result",
     [resultKindSymbol]: "Err",
-    isOk: () => false,
-    isErr: () => true,
-    isOkAnd: (_predicate) => false,
-    isErrAnd: (predicate) => predicate(error),
-    expect: (msg) => {
+    isOk() {
+      return false;
+    },
+    isErr() {
+      return true;
+    },
+    isOkAnd(_predicate) {
+      return false;
+    },
+    isErrAnd(predicate) {
+      return predicate(error);
+    },
+    expect(msg) {
       throw new TypeError(`${msg}: ${error}`);
     },
-    unwrap: () => {
+    unwrap() {
       throw new TypeError("Called `Result::unwrap()` on an `Err` value");
     },
-    unwrapOr: (defaultValue) => defaultValue,
-    unwrapOrElse: (fn) => fn(error),
-    expectErr: (_msg) => error,
-    unwrapErr: () => error,
-    ok: () => None,
-    err: () => Some(error),
-    transpose: () => Some(err),
-    map: (_fn) => err,
-    mapErr: (fn) => Err(fn(error)),
-    mapOr: (defaultValue, _fn) => defaultValue,
-    mapOrElse: (defaultFn, _fn) => defaultFn(error),
-    flatten: () => err,
-    and: (_other) => err,
-    or: (other) => {
+    unwrapOr(defaultValue) {
+      return defaultValue;
+    },
+    unwrapOrElse(fn) {
+      return fn(error);
+    },
+    expectErr(_msg) {
+      return error;
+    },
+    unwrapErr() {
+      return error;
+    },
+    ok() {
+      return None;
+    },
+    err() {
+      return Some(error);
+    },
+    transpose() {
+      return Some(err);
+    },
+    map(_fn) {
+      return err;
+    },
+    mapErr(fn) {
+      return Err(fn(error));
+    },
+    mapOr(defaultValue, _fn) {
+      return defaultValue;
+    },
+    mapOrElse(defaultFn, _fn) {
+      return defaultFn(error);
+    },
+    flatten() {
+      return err;
+    },
+    and(_other) {
+      return err;
+    },
+    or(other) {
       assertResult(other);
       return other;
     },
-    andThen: (_fn) => err,
-    orElse: (fn) => fn(error),
-    inspect: (_fn) => err,
-    inspectErr: (fn) => {
+    andThen(_fn) {
+      return err;
+    },
+    orElse(fn) {
+      return fn(error);
+    },
+    inspect(_fn) {
+      return err;
+    },
+    inspectErr(fn) {
       fn(error);
       return err;
     },
-    eq: (other) => {
+    eq(other) {
       assertResult(other);
       return other.isErr() && other.unwrapErr() === error;
+    },
+    asOk() {
+      throw new TypeError("Called `Result::asOk()` on an `Err` value");
+    },
+    asErr() {
+      return err;
+    },
+    toString() {
+      return `Err(${error})`;
     }
   };
   return err;
 }
 function assertOption(o) {
-  if (o == null || typeof o !== "object" || !(optionKindSymbol in o)) {
+  if (!isOption(o)) {
     throw new TypeError(`This(${o}) is not an Option`);
   }
 }
 function assertResult(r) {
-  if (r == null || typeof r !== "object" || !(resultKindSymbol in r)) {
+  if (!isResult(r)) {
     throw new TypeError(`This(${r}) is not a Result`);
   }
 }
@@ -218,6 +394,12 @@ function promiseToResult(p) {
     return Err(err);
   });
 }
+function isOption(o) {
+  return o != null && typeof o === "object" && optionKindSymbol in o;
+}
+function isResult(r) {
+  return r != null && typeof r === "object" && resultKindSymbol in r;
+}
 
-export { Err, None, Ok, Some, promiseToResult };
+export { Err, None, Ok, Some, isOption, isResult, promiseToResult };
 //# sourceMappingURL=main.mjs.map