{"id":23379023,"url":"https://github.com/colevoss/result-ts","last_synced_at":"2025-08-08T16:19:59.716Z","repository":{"id":142726242,"uuid":"537237410","full_name":"colevoss/result-ts","owner":"colevoss","description":null,"archived":false,"fork":false,"pushed_at":"2023-10-11T04:04:31.000Z","size":496,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":2,"default_branch":"main","last_synced_at":"2025-03-29T01:01:32.677Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/colevoss.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-09-15T23:25:06.000Z","updated_at":"2023-03-10T08:36:04.000Z","dependencies_parsed_at":"2023-12-14T02:45:53.416Z","dependency_job_id":null,"html_url":"https://github.com/colevoss/result-ts","commit_stats":{"total_commits":9,"total_committers":2,"mean_commits":4.5,"dds":0.4444444444444444,"last_synced_commit":"93b68986a91e94237b584ce236aa6cc3624ba636"},"previous_names":[],"tags_count":0,"template":false,"template_full_name":"colevoss/typescript-node-boilerplate","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/colevoss%2Fresult-ts","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/colevoss%2Fresult-ts/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/colevoss%2Fresult-ts/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/colevoss%2Fresult-ts/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/colevoss","download_url":"https://codeload.github.com/colevoss/result-ts/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247785942,"owners_count":20995644,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-12-21T19:16:11.179Z","updated_at":"2025-04-08T05:50:22.194Z","avatar_url":"https://github.com/colevoss.png","language":"TypeScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Result TS\n\nThis package provides [`Result\u003cT, E\u003e`](https://doc.rust-lang.org/std/result/) and [`Option\u003cT\u003e`](https://doc.rust-lang.org/std/option/) classes heavily inspired by Rust's standard library equivalents.\n\n## Why\n\nAfter writing some Rust code, I realized how nice the `Result` and `Option` types\nare to use. I wanted to have the same powerful types in my TypeScript code.\nI have no idea if these types will actually be usable, but creating this package\nallowed me to learn Rust's types even better as well as improving my TypeScript skills.\n\nRust has some very helpful language primitives like `match` and `?` that empower\nthese types even further, and I've tried to capture some of the value of those\nlanguage features in this library as well.\n\n\n## Docs\n- [Result\u003cT, E\u003e](#resultt-e)\n  - [and](#and)\n  - [andThen](#andthen)\n  - [err](#err)\n  - [expect](#expect)\n  - [expectErr](#expecterr)\n  - [inspect](#inspect)\n  - [inspectErr](#inspecterr)\n  - [isErr](#iserr)\n  - [isErrAnd](#iserrand)\n  - [isOk](#isok)\n  - [isOkAnd](#isokand)\n  - [map](#map)\n  - [mapOr](#mapor)\n  - [mapOrElse](#maporelse)\n  - [ok](#ok)\n  - [or](#or)\n  - [orElse](#orelse)\n  - [unwrap](#unwrap)\n  - [unwrapErr](#unwraperr)\n  - [unwrapOr](#unwrapor)\n  - [unwrapOrElse](#unwraporelse)\n- [Option\u003cT\u003e](#optiont)\n  - [and](#and-1)\n  - [andThen](#andthen-1)\n  - [expect](#expect-1)\n  - [filter](#filter)\n  - [inspect](#inspect-1)\n  - [isNone](#isnone)\n  - [isSome](#issome)\n  - [isSomeAnd](#issomeand)\n  - [map](#map-1)\n  - [mapOr](#mapor-1)\n  - [mapOrElse](#maporelse-1)\n  - [okOr](#okor)\n  - [okOrElse](#okorelse)\n  - [or](#or-1)\n  - [orElse](#orelse-1)\n  - [unwrap](#unwrap-1)\n  - [unwrapOr](#unwrapor-1)\n  - [unwrapOrElse](#unwraporelse-1)\n  - [xor](#xor)\n\n\n## Result\u003cT, E\u003e\n\n```ts\n// Example Results\n\nconst okResult = new Ok('ok value');\nconst errResult = new Err('error value');\n```\n\n### and\n\n```ts\nand\u003cU\u003e(andValue: Result\u003cU, E\u003e): Result\u003cU, E\u003e\n```\n\nReturns `andValue` if the Result is `Ok`, otherwise returns `Err` value.\n\n**Examples**\n\n```ts\nconst x = new Ok('x');\nconst y = new Ok('y')\n\nconst xAndY = x.and(y);\nassert.equal(xAndY.unwrap(), 'y');\n\nconst x = new Err('early error');\nconst y = new Ok('y');\n\nconst xAndY = x.and(y);\nassert.equal(x.unwrapErr(), 'early error');\n\nconst x = new Ok('x');\nconst y = new Err('late error');\n\nconst xAndY = x.and(y);\nassert.equal(xAndY.unwrapErr(), 'late error');\n\nconst x = new Err('early error');\nconst y = new Err('late error');\n\nconst xAndY = x.and(y);\nassert.equal(xAndY.unwrapErr(), 'early error');\n```\n\n### andThen\n\n```ts\nandThen\u003cU\u003e(cb: (v: T) =\u003e Result\u003cU, E\u003e): Result\u003cU, E\u003e\n```\n\nCalls `cb` if Result is `Ok`, otherwise returns `Err\u003cE\u003e`.\n\n**Examples**\n\n```ts\nconst x = new Ok('x');\nconst y = x.andThen((xVal) =\u003e {\n  return new Ok(xVal + ' new')\n});\nassert.equal(y.unwrap(), 'x new');\n\nconst x = new Ok('x');\nconst y = x.andThen((xVal) =\u003e {\n  return new Err('error')\n});\nassert.equal(y.unwrapErr(), 'error');\n\nconst x = new Err('early error'):\nconst y = x.andThen(() =\u003e {\n  return new Ok('ok')\n});\nassert.equal(y.unwrapErr(), 'early error');\n```\n\n### err\n\n```ts\nerr(): Option.Option\u003cE\u003e\n```\n\nConverts from `Result\u003cT, E\u003e` to `Option\u003cE\u003e`\n\n**Examples**\n\n```ts\nconst x = new Err('error');\nconst y = x.err(); // Some('error')\n\nassert.ok(y.isSome());\nassert.equal(y.unwrap(), 'error')\n\nconst x = new Ok('ok');\nconst y = x.err(); // None\n\nassert.ok(y.isNone());\n```\n\n### expect\n\n```ts\nexpect(reason: string): T\n```\n\nReturns the contained value `T` if value is `Ok`.\n\n**Throws**\n\nThrows error if Result is `Err` with provided reason as message and `cause` as `this`\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok('ok value');\n\nconst xVal = x.expect('Should be ok value');\nassert.equal(xVal, 'ok value')\n\n// Err\nconst x = new Err('error value');\nconst xVal = x.expect('should be ok value');\n\n// Throws:\n// Error: should be ok value\n//   [cause]: Err [ResultError]: error value\n//     type: 'ResultError',\n//     error: 'error value'\n//   }\n// }\n```\n\n### expectErr\n\n```ts\nexpectErr(reason: string): E\n```\n\nReturns the contained `Err` value.\n\n**Throws**\n\nThrows contained value `T` if Result is `Ok\u003cT\u003e`\n\n```ts\n// Err\nconst x = new Err('err value');\n\nconst xVal = x.expectErr('should be err value');\nassert.equal(xVal, 'err value')\n\n// Ok\nconst x = new Ok('ok value')\nconst xVal = x.expectErr('should be err value')\n\n// Throws \n// Error: should be error value\n//   [cause]: 'ok value'\n// }\n```\n\n### inspect\n\n```ts\ninspect(cb: (v: T) =\u003e void): this\n```\n\nCalls the provided function with contained value if Result is `Ok`.\n\nIgnores callback if Result is `Err`\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok('ok value');\nx.inspect((xVal) =\u003e {\n  // logs \"val: ok value\"\n  console.log(\"val: \", xVal)\n}); // returns x\n\n// Err\nconst x = new Err('err value');\nx.inspect(() =\u003e {\n  // is not called\n});\n```\n\n### inspectErr\n\n```ts\ninspectErr(cb: (e: E) =\u003e void): this\n```\n\nCalls the provided function with contained error if Result is `Err`\n\nIgnores callback if Result is `Ok`\n\n**Examples**\n\n```ts\n// Err\nconst x = new Err('error value');\nx.inspectErr((xVal) =\u003e {\n  assert.equal(xVal, 'error value');\n}); // returns x\n\n// Ok\nconst x = new Ok('ok value');\nx.inspectErr(() =\u003e {\n  // is not called\n})\n```\n\n### isErr\n\n```ts\nisErr(): this is Err\u003cE\u003e; // boolean\n```\n\nReturns `false` if Result is `Err`\n\n**Example**\n\n```ts\nconst x = new Ok();\nassert.ok(!x.isErr());\n\nconst y = new Err('error');\nassert.ok(y.isErr())\n```\n\n### isErrAnd\n\n```ts\nisErrAnd(cb: (v: E) =\u003e boolean): boolean\n```\n\nReturns `true` when Result is `Err` and the contained error matches predicate\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Err(1);\nconst y = x.isErrAnd((xVal) =\u003e {\n  return x === 1;\n});\n\nassert.ok(y);\n\n// Err\nconst x = new Ok(1);\nconst y = x.isErrAnd((xVal) =\u003e {\n  // is not called\n});\nassert.ok(!y);\n```\n\n### isOk\n\n```ts\nisOk(): this is Ok\u003cT\u003e; // boolean\n```\n\nReturns `true` if Result is `Ok`\n\n**Example**\n\n```ts\nconst x = new Ok();\nassert.ok(x.isOk())\n\nconst y = new Err('error');\nassert.ok(!y.isOk())\n```\n\n### isOkAnd\n\n```ts\nisOkAnd(cb: (v: T) =\u003e boolean): boolean\n```\n\nReturns `true` when Result is Ok and the contained value matches predicate\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok(1);\nconst y = x.isOkAnd((xVal) =\u003e {\n  return x === 1;\n});\nassert.ok(y);\n\n// Err\nconst x = new Err(1);\nconst y = x.isOkAnd((xVal) =\u003e {\n  // is not called\n});\nassert.ok(!y);\n```\n\n### map\n\n```ts\nmap\u003cU\u003e(cb: (value: T) =\u003e U): Result\u003cU, E\u003e\n```\n\nMaps `Result\u003cT, E\u003e` to `Result\u003cU, E\u003e` by applying a function to a contained `Ok`\nvalue and ignores if `Err`.\n\n**Examples**\n\n```ts\nconst x = new Ok('ok');\nconst y = x.map((xVal) =\u003e {\n  return xVal.length;\n});\nassert.equal(y.unwrap(), 2);\n```\n\n### mapOr\n\n```ts\nmapOr\u003cU\u003e(cb: (v: T) =\u003e U, orValue: U): U\n```\n\nReturns the provided default if Result is `Err` otherwise applies a function\nto the contained `Ok` value (if `Ok`).\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok('ok');\nconst y = x.mapOr((xVal) =\u003e {\n  return xVal.length;\n}, 10);\nassert.equal(y, 2);\n\n// Err\nconst x = new Err('err');\nconst y = x.mapOr((xVal) =\u003e {\n  return xVal.length;\n}, 10);\nassert.equal(y, 10);\n```\n\n### mapOrElse\n\n```ts\nmapOrElse\u003cU\u003e(okCb: (v: T) =\u003e U, errCb: (e: Err\u003cE\u003e) =\u003e U): U\n```\n\nMaps a `Result\u003cT, E\u003e` to `U` by applying fallback function `errCb` to a contained\n`Err` value, or function `okCb` to a contained `Ok` value.\n\n**Examples**\n\n```ts\n// Ok\nconst cb = (val) =\u003e val.length;\n\nconst x = new Ok('ok');\nconst y = x.mapOrElse(cb, cb);\nassert.equal(y, 2);\n\n// Err\nconst x = new Err('err');\nconst y = x.mapOrElse(cb, cb);\nassert.equal(y, 3);\n```\n\n### ok\n\n```ts\nok(): Option\u003cT\u003e\n```\n\nConverts from `Result\u003cT, E\u003e` to `Option\u003cT\u003e`. `Ok\u003cT\u003e` is converted to `Some\u003cT\u003e` and\n`Err\u003cE\u003e` is converted to `None`.\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok('ok val');\nconst y = x.ok();\nassert.ok(y.isSome());\nassert.equal(y.unwrap(), 'ok val'):\n\n// Err\nconst x = new Err('err val');\nconst y = x.ok();\nassert.ok(y.isNone());\n```\n\n### or\n\n```ts\nor\u003cF\u003e(orValue: Result\u003cT, F\u003e): Result\u003cT, F\u003e\n```\n\nReturns `orValue` if Result is `Err` otherwise returns `Ok`\n\n**Examples**\n\n```ts\n// Ok or Err\nconst x = new Ok('ok');\nconst y = new Err('late error');\nconst xOrY = x.or(y);\nassert.ok(xOrY.isOk());\nassert.equal(xOrY.unwrap(), 'ok');\n\n// Err or Ok\nconst x = new Err('early error');\nconst y = new Ok('ok');\nconst xOrY = x.or(y);\nassert.ok(xOrY.isOk());\nassert.equal(xOrY.unwrap(), 'ok');\n\n// Err or Err\nconst x = new Err('early error');\nconst y = new Err('late error');\nconst xOrY = x.or(y);\nassert.ok(xOrY.isErr());\nassert.equal(xOrY.unwrapErr(), 'late error');\n\n// Ok or Ok\nconst x = new Ok('ok');\nconst y = new Ok('late ok');\nconst xOrY = x.or(y);\nassert.ok(xOrY.isOk());\nassert.equal(xOrY.unwrap(), 'ok');\n```\n\n### orElse\n\n```ts\norElse\u003cF\u003e(cb: (e: E) =\u003e Result\u003cT, F\u003e): Result\u003cT, F\u003e;\n```\n\nCalls `cb` if Result is `Err`, otherwise returns `Ok`\n\n**Examples**\n\n```ts\nconst o = new Ok('o')\nconst e = new Err('e')\nconst createOk = () =\u003e new Ok('ok');\nconst createErr = () =\u003e new Err('err');\n\nassert.equal(o.orElse(createOk).unwrap(), 'o')\nassert.equal(o.orElse(createErr).unwrap(), 'o')\nassert.equal(e.orElse(createOk).unwrap(), 'ok')\nassert.equal(e.orElse(createErr).unwrapErr(), 'err')\n```\n\n### unwrap\n\n```ts\nunwrap(): T\n```\n\nIf value is `Ok\u003cT\u003e` returns `T`.\n\n**Throw**\n\nThrows error if value is `Err`\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok('ok val');\nassert.equal(x.unwrap(), 'ok val');\n\n// Err\nconst x = new Err('err val');\n\nx.unwrap() // Throws\n// Err [ResultError]: err val\n//   type: 'ResultError',\n//   error: 'err val'\n// }\n```\n\n### unwrapErr\n\n```ts\nunwrapErr(): E\n```\n\nIf Result is `Err` returns E.\n\n**Throws**\n\nThrows error if value is Ok\n\n**Examples**\n\n```ts\n// Err\nconst x = new Err('err val');\nassert.equal(x.unwrapErr(), 'err val');\n\n\n// Ok\nconst x = new Ok('ok val')\nx.unwrapErr(); // Throws\n// Err [ResultError]: ok val\n//   type: 'ResultError',\n//   error: 'ok val'\n// }\n```\n\n### unwrapOr\n\n```ts\nunwrapOr(orValue: T): T\n```\n\nReturns the contained `Ok` value or provided default\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Ok(1);\nassert.equal(x.unwrapOr(0), 1);\n\n// Err\nconst x = new Err('error');\nassert.equal(x.unwrapOr(0), 0);\n```\n\n### unwrapOrElse\n\n```ts\nunwrapOrElse(cb: (e: E) =\u003e T): T\n```\n\nReturns the contained `Ok` value or computes it from callback\n\n```ts\nconst cb = (err) =\u003e 'or else';\n\n// Ok\nconst x = new Ok('ok');\nassert.equal(x.unwrapOrElse(cb), 'ok')\n\n// Err\nconst x = new Err('ok');\nassert.equal(x.unwrapOrElse(cb), 'or else')\n```\n\n## Option\u003cT\u003e\n\n```ts\n// Example Option\n\nconst someOption = new Some('some value');\nconst noneOption = new None();\n```\n\n### and\n\n```ts\nand\u003cU\u003e(andValue: Option\u003cU\u003e): Option\u003cU\u003e;\n```\n\nReturns `andValue` if the Result is `Ok`, otherwise returns `Err` value.\n\n**Examples**\n\n```ts\n// Some and None\nconst x = new Some(1);\nconst y = new None();\nassert.ok(x.and(y).isNone());\n\n// None and Some\nconst x = new None();\nconst y = new Some(1);\nassert.ok(x.and(y).isNone())\n\n// Some and Some\nconst x = new Some(1);\nconst y = new Some(2);\nassert.equal(x.and(y).unwrap(), 2);\n\n// None and None\nconst x = new None();\nconst y = new None();\nassert.ok(x.and(y).isNone());\n```\n\n### andThen\n\n```ts\nandThen\u003cU\u003e(cb: (v: T) =\u003e Option\u003cU\u003e): Option\u003cU\u003e\n```\n\nReturns `None` if Option is `None`, otherwise calls `cb` with contained value and\nreturns result.\n\n**Example**\n\n```ts\n// Some and Some\nconst x = new Some('some');\nconst y = x.andThen((xVal) =\u003e new Some(xVal + 'thing'));\nassert.equal(y.unwrap(), 'something');\n\n// Some and None\nconst x = new Some('some');\nconst y = x.andThen((xVal) =\u003e new None());\nassert.ok(y.isNone());\n\n// None and Some\nconst x = new None();\nconst y = x.andThen(() =\u003e new Some('some'));\nassert.ok(y.isNone());\n\n// None and None\nconst x = new None();\nconst y = x.andThen(() =\u003e new None());\nassert.ok(y.isNone());\n```\n\n### expect\n\n```ts\nexpect(reason: string): T\n```\n\nReturns the contained valued `T` if value is `Some`\n\n**Throw**\n\nThrows error is Option is `None` with provided reason as message.\n\n**Examples**\n\n```ts\n// Ok\nconst x = new Some('some')\nassert.equal(x.expect('should be some'), 'ok');\n\n// Err\nconst x = new None()\nx.expect('should be some'): // Throws\n// Err [ResultError]: should be some\n//   type: 'ResultError',\n//   error: 'should be some'\n// }\n```\n\n### filter\n\n```ts\nfilter(predicate: (v: T) =\u003e boolean): Option\u003cT\u003e\n```\n\nReturns `None` if the option is `None`, otherwise calls `predicate` with the contained\nvalue and returns:\n* `Some\u003cT\u003e` if `predicate` returns `true`.\n* `None` if `predicate` returns `false`.\n\n**Examples**\n\n```ts\nconst isEven = (n) =\u003e n % 2 === 0\n\nconst odd = new Some(1):\nassert.ok(odd.filter(isEven).isNone());\n\nconst even = new Some(2);\nassert.ok(even.filter(isEven).isSome());\nassert.equal(even.filter(isEven).unwrap(), 2);\n\nconst none = new None();\nassert.ok(none.filter(isEven).isNone());\n```\n\n### inspect\n\n```ts\ninspect(cb: (v: T) =\u003e void): this\n```\n\nCalls the provided `cb` with contained value (if `Some`)\n\n**Examples**\n\n```ts\n// Some\nconst x = new Some('some val')\nx.inspect((someVal) =\u003e {\n  // logs \"val: some val\"\n  console.log('val:', someVal);\n});\n\n// None\nconst x = new None()\nx.inspect((someVal) =\u003e {\n  // not called\n});\n```\n\n### isNone\n\n```ts\nisNone(): this is None;\n```\n\nReturns `true` if Option is `None`\n\n**Examples**\n\n```ts\n// Some\nconst x  = new Some('some');\nassert.ok(!x.isNone());\n\n// None\nconst x = new None();\nassert.ok(x.isNone());\n```\n\n### isSome\n\n```ts\nisSome(): this is Some\u003cT\u003e\n```\n\nReturns `true` if Option is `Some`\n\n**Examples**\n\n```ts\n// Some\nconst x = new Some('some');\nassert.ok(x.isSome());\n\n// None\nconst x = new None();\nassert.ok(!x.isSome());\n```\n\n### isSomeAnd\n\n```ts\nisSomeAnd(cb: (v: T) =\u003e boolean): boolean\n```\n\nIf type is `Some\u003cT\u003e` returns value returned by the given callback.\nIf type is `None`, returns false.\n\n**Examples**\n\n```ts\n// Some\nconst isOne = (n) =\u003e n === 1;\nconst x = new Some(1);\nconst y = new Some(2);\nassert.ok(x.isSomeAnd(isOne));\nassert.ok(!y.isSomeAnd(isOne));\n\n// None\nconst x = new None();\nassert.ok(!x.isSomeAnd(isOne));\n```\n\n### map\n\n```ts\nmap\u003cU\u003e(cb: (value: T) =\u003e U): Option\u003cU\u003e\n```\n\nMaps `Option\u003cT\u003e` to `Option\u003cU\u003e` by applying a function to a contained `Option` value\nand ignores `None`.\n\n**Examples**\n\n```ts\nconst len = (s) =\u003e s.length;\n\n// Some\nconst x = new Some('some');\nassert.equal(x.map(len).unwrap(), 4);\n\n// None\nconst y = new None();\nassert.ok(y.map(len).isNone());\n```\n\n### mapOr\n\n```ts\nmapOr\u003cU\u003e(cb: (value: T) =\u003e U, orValue: U): U;\n```\n\nReturns the provided default if Option is `None` otherwise applies a function to\nthe contained `Option` value (if `Some`).\n\n**Examples*\n\n```ts\nconst len = (s) =\u003e s.length;\n\n// Some\nconst x = new Some('some');\nassert.equal(x.mapOr(len, 0), 4);\n\n// None\nconst x = new None();\nassert.equal(x.mapOr(len, 0), 0);\n```\n\n### mapOrElse\n\n```ts\nmapOrElse\u003cU\u003e(someCb: (v: T) =\u003e U, noneCb: () =\u003e U): U\n```\n\nMaps an `Option\u003cT\u003e` to `U` by calling a fallback function `noneCb`, or `someCb`\nto a contained `Some` value\n\n**Examples**\n\n```ts\nconst len = (s) =\u003e s.length;\nconst noneLen = () =\u003e 10000;\n\n// Some\nconst x = new Some('some');\nassert.equal(x.mapOrElse(len, noneLen), 4);\n\nconst x = new None();\nassert.equal(x.mapOrElse(len, noneLen), 10000);\n```\n\n### okOr\n\n```ts\nokOr\u003cE\u003e(errValue: E): Result\u003cT, E\u003e\n```\n\nTransforms the `Option\u003cT\u003e` into `Result\u003cT, E\u003e`, mapping `Some\u003cT\u003e` to `Ok\u003cT\u003e` and\n`None` to `Err\u003cE\u003e`.\n\n**Examples**\n\n```ts\n// Some\nconst x = new Some('some');\nconst res = x.okOr('bad');\nassert.ok(res.isOk());\nassert.equal(res.unwrap(), 'some');\n\n// None\nconst x = new None();\nconst res = x.okOr('bad')\nassert.ok(res.isErr());\nassert.equal(res.unwrapErr(), 'bad');\n```\n\n### okOrElse\n\n```ts\nokOrElse\u003cE\u003e(errCb: () =\u003e E): Result\u003cT, E\u003e\n```\n\nTransforms the `Option\u003cT\u003e` into `Result\u003cT, E\u003e`, mapping `Some\u003cT\u003e` to `Ok\u003cT\u003e` and\n`None` to `Err\u003cerrCb()\u003e`.\n\n**Examples**\n\n```ts\nconst orElseZero = () =\u003e 0;\n\n// Some\nconst x = new Some(1);\nconst res = x.okOrElse(orElseZero);\nassert.ok(x.isOk());\nassert.equal(x.unwrap(), 1);\n\n// None\nconst x = new None();\nconst res = x.okOrElse(orElseZero);\nassert.ok(x.isErr());\nassert.equal(x.unwrapErr(), 0);\n```\n\n### or\n\n```ts\nor(orValue: Option\u003cT\u003e): Option\u003cT\u003e\n```\n\nReturns the option if it contains a value, otherwise returns `orValue`.\n\n**Examples**\n\n```ts\n// Some or Some\nconst x = new Some(1);\nconst y = new Some(2);\nconst or = x.or(y);\n\nassert.equal(x.unwrap(), 1);\n\n// Some or None\nconst x = new Some(1);\nconst y = new None();\nconst or = x.or(y);\n\nassert.equal(x.unwrap(), 1);\n\n// None or Some\nconst x = new None();\nconst y = new Some(2);\nconst or = x.or(y);\n\nassert.equal(x.unwrap(), 2);\n\n// None or None\nconst x = new None();\nconst y = new None();\nconst or = x.or(y);\n\nassert.ok(x.isNone());\n```\n\n### orElse\n\n```ts\norElse(cb: () =\u003e Option\u003cT\u003e): Option\u003cT\u003e\n```\n\nReturns the option if it contains a value, otherwise calls `cb` and returns the result.\n\n**Examples**\n\n```ts\nconst orNone = () =\u003e new None();\nconst orSome = () =\u003e new Some(10);\n\n// Some or Some\nconst x = new Some(1);\nconst orElse = x.orElse(orSome);\nassert.equal(x.unwrap(), 1);\n\n// Some or None\nconst x = new Some(1);\nconst orElse = x.orElse(orNone);\nassert.equal(x.unwrap(), 1);\n\n// None or Some\nconst x = new None(1);\nconst orElse = x.orElse(orSome);\nassert.equal(x.unwrap(), 10);\n\n// None or Some\nconst x = new None(1);\nconst orElse = x.orElse(orNone);\nassert.ok(x.isNone());\n```\n\n### unwrap\n\n```ts\nunwrap(): T\n```\n\nIf value is `Some\u003cT\u003e` returns `T`.\n\n**Throws**\n\nThrows error if Option is `None`\n\n**Examples**\n\n```ts\n// Some\nconst x = new Some('some value');\nassert.equal(x.unwrap(), 'some value');\n\n// None\nconst x = new None();\nx.unwrap(); // Throws\n// Err [ResultError]: Option value is None\n//   type: 'ResultError',\n//   error: 'Option value is None'\n// }\n```\n\n### unwrapOr\n\n```ts\nunwrapOr(orValue: T): T;\n```\n\nIf value is `Some\u003cT\u003e` returns `T`.\nIf value is `None` returns given `orValue`\n\n**Examples**\n\n```ts\n// Some\nconst x = new Some('some value');\nassert.equal(x.unwrapOr('none value'), 'some value');\n\n// None\nconst x = new None();\nassert.equal(x.unwrapOr('none value'), 'none value');\n```\n\n### unwrapOrElse\n\n```ts\nunwrapOrElse(cb: () =\u003e T): T\n```\n\nReturns the contained `Some` value or computes it from the given callback.\n\n**Examples**\n\n```ts\nconst orElse = () =\u003e 'or else';\n\n// Some\nconst x = new Some('some');\nassert.equal(x.unwrapOrElse(orElse), 'some')\n\n// None\nconst x = new None();\nassert.equal(x.unwrapOrElse(orElse), 'or else')\n```\n\n### xor\n\n```ts\nxor(xorValue: Option\u003cT\u003e): Option\u003cT\u003e\n```\n\nReturns `Some` if exactly one of `this` or `xorValue` is `Some`, otherwise returns\n`None`\n\n```ts\n// Some xor Some\nconst x = new Some(1);\nconst y = new Some(2);\nconst xor = x.xor(y);\nassert.ok(x.isNone());\n\n// Some xor None\nconst x = new Some(1);\nconst y = new None();\nconst xor = x.xor(y);\nassert.ok(x.isSome());\nassert.equal(x.unwrap(), 1);\n\n// Some xor None\nconst x = new None();\nconst y = new Some(2);\nconst xor = x.xor(y);\nassert.ok(x.isSome());\nassert.equal(x.unwrap(), 2);\n\n// None xor None\nconst x = new None();\nconst y = new Some(2);\nconst xor = x.xor(y);\nassert.ok(x.isNone());\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcolevoss%2Fresult-ts","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcolevoss%2Fresult-ts","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcolevoss%2Fresult-ts/lists"}