Another inspired Rust's Result implementation.
npm install @openally/result
Another Rust's Result implementation (inspired by ts-results)
This package is available in the Node Package Repository and can be easily installed with npm or yarn.
``bash`
$ npm i @openally/resultor
$ yarn add @openally/result
`ts
import fs from "node:fs";
import { Result, Ok, Err } from "@openally/result";
function readFile(path: string): Result
if (existsSync(path)) {
return Ok(fs.readFileSync(path, "utf8"));
}
return Err("invalid path");
}
const fileContentStr = readFile("test.txt").unwrap();
console.log(fileContentStr);
`
Where Result could be either an Ok or Err
`ts`
type Result
---
You can combine that package with ts-pattern, here is an example;
`ts`
return match(constraint.type)
.with("PRIMARY KEY", () => (
column.isPrimary ? None : Some({ columnName, type: "MISSING PK" })
))
.with("UNIQUE", () => helper
.getUniqueByColumnName(columnName)
.unwrapOr(Some({ columnName, type: "MISSING UNIQUE" }))
)
.with("FOREIGN KEY", () => helper
.getForeignKeyByColumnName(columnName)
.andThen((fk) => {
return helper.fkIsMatchingConstraint(fk, constraint) ?
Some({ columnName, type: "INVALID FK REFERENCE", constraint }) :
None;
})
.unwrapOr(Some({ columnName, type: "MISSING FK" }))
)
.otherwise(() => None) as Option
Where Option is defined as being Some value or None.
`ts`
type Option
`ts`
Ok(1).unwrap(); // 1
Err("oops").unwrap(); // Error: Tried to unwrap Error: oops
`ts`
Ok(1).unwrapOr(5); // 1
Err("oops").unwrapOr(5); // 5
but use a lazy function for the default value.`ts
Ok(1).unwrapOrElse(() => 5); // 1
Err("oops").unwrapOrElse(() => 5); // 5
`$3
Same as unwrap but only available for Ok (useful for type safety).$3
Map value for Ok. Do nothing with Err (use mapErr instead).`ts
Ok(1)
.map((v) => v + 1)
.unwrap(); // 2
`$3
Map and unwrap:
- Use default value for Error
- Use mapper for Ok`ts
Ok(1)
.mapOr(1, (val) => val * 2); // 2Err(new Error("oops"))
.mapOr(1, (val) => val * 2); // 1
`$3
Same as mapOr but use a callback returning error for default value`ts
Err(new Error("oops"))
.mapOrElse(
(err) => err.message),
(val) => val * 2
); // oops
`$3
Map value for Err. Do nothing with Ok (use map instead).`ts
Err(new Error("oops"))
.mapErr((cause) => new Error("oh no", { cause }))
.unwrap();
`$3
Similar to Promise.then, map and transform an Ok value.`ts
Ok(1)
.andThen((value) => Ok(value + 1))
.unwrap(); // 2
`This could be used to transform an Ok to an Err.
$3
Return the Err stacktrace (not available for Ok).`ts
const _e = Err(new Error());
console.log(_e.stack);
``