121 lines
2.6 KiB
Markdown
121 lines
2.6 KiB
Markdown
# rust-result.js
|
|
|
|
Mimic Rust's [`std::result`][result].
|
|
|
|
## Installation
|
|
|
|
```sh
|
|
npm install rust-result
|
|
```
|
|
|
|
## Usage
|
|
|
|
```js
|
|
var fs = require('fs');
|
|
var Result = require('./');
|
|
|
|
|
|
// If you want async just get a promise or something.
|
|
var readFile = function (path, encoding) {
|
|
try {
|
|
return Result.Ok(fs.readFileSync(path, encoding))
|
|
}
|
|
catch (ex) {
|
|
return Result.Err(ex)
|
|
}
|
|
}
|
|
|
|
var result = readFile(__filename);
|
|
var v, err;
|
|
|
|
if (Result.isOk(result)) {
|
|
v = Result.Ok(result);
|
|
console.log('got ' + v.length + ' bytes')
|
|
}
|
|
else if (Result.isErr(result)) {
|
|
err = Result.Err(result);
|
|
console.error('oops!', err.message)
|
|
}
|
|
|
|
result = readFile(__filename + 'I do not exist')
|
|
if (Result.isOk(result)) {
|
|
v = Result.Ok(result)
|
|
console.log('got ' + v.length + ' bytes')
|
|
}
|
|
else if (Result.isErr(result)) {
|
|
err = Result.Err(result)
|
|
console.error('oops!', err.message)
|
|
}
|
|
|
|
```
|
|
|
|
## Documentation
|
|
|
|
```jsig
|
|
type OkResult<T> : {
|
|
v: T
|
|
}
|
|
type ErrResult<E <: Error> : {
|
|
err: E
|
|
}
|
|
|
|
rust-result : {
|
|
Ok: ((T) => OkResult<T>) |
|
|
((OkResult<T>) => T) |
|
|
((ErrResult<E>) => void),
|
|
isOk: ((OkResult<T>) => true) |
|
|
((ErrResult<E>) => false)
|
|
Err: ((E <: Error) => ErrResult<E>) |
|
|
((ErrResult<E>) => E) |
|
|
((OkResult<T>) => void),
|
|
isErr: ((ErrResult<E>) => true) |
|
|
((OkResult<T>) => false)
|
|
}
|
|
```
|
|
|
|
### `Result.Ok`
|
|
|
|
The `Result.Ok` function is overloaded to do one of two things.
|
|
It can create a new `Ok` instance or it can check whether
|
|
the argument is an instance of `Ok`
|
|
|
|
If you call `Result.Ok` with a plain value it will return an
|
|
instance of `Ok` that boxes your plain value.
|
|
|
|
If you call `Result.Ok` with either an `Err` or an `Ok` instance
|
|
then it will return `undefined` for the `Err` and return the
|
|
value boxed in the `Ok`
|
|
|
|
### `Result.isOk`
|
|
|
|
The `Result.isOk` function just checks whether the argument
|
|
is an instance of `Ok`.
|
|
|
|
This predicate function returns true if you pass it an `Ok` and
|
|
returns false if you pass it an `Err`
|
|
|
|
### `Result.Err`
|
|
|
|
The `Result.Err` function is overloaded to do one of two things.
|
|
It can create a new `Err` instance or it can check whether
|
|
the argument is an instance of `Err`
|
|
|
|
If you call `Result.Err` with a plain error it will return an
|
|
instance of `Err` that boxes your plain error.
|
|
|
|
If you call `Result.Err` with either an `Err` or an `Ok` instance
|
|
then it will return `undefined` for the `Ok` and return the
|
|
value err in the `Err`
|
|
|
|
### `Result.isErr`
|
|
|
|
The `Result.isErr` function just checks whether the argument
|
|
is an instance of `Err`.
|
|
|
|
This predicate function returns true if you pass it an `Err` and
|
|
returns false if you pass it an `Ok`
|
|
|
|
## MIT Licenced.
|
|
|
|
[result]: http://doc.rust-lang.org/std/result/
|