2a09d1a4
 liuqimichale
添加宜春 天水 宣化
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
# 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/
|
