mayak 0.0.3 → 0.0.5
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/lib/mayak/monads/README.md +29 -74
- data/lib/mayak/monads/maybe.rb +86 -21
- data/lib/mayak/monads/result.rb +119 -70
- data/lib/mayak/monads/try.rb +78 -41
- data/mayak.gemspec +1 -1
- metadata +2 -2
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA256:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: d3d6392483fc1750edbb5b8769f26ff2b5e481b833c2c558d39705328bbf4b67
|
4
|
+
data.tar.gz: a857d9f7f887e00b17e45417e5c0cd9735a298d1cbc872e356b7be39f3f9674c
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: ace47144adc22d958b094723be44eab7539795aae79ed580dfc1b0f85c6caa6d7745c30867797c4e6de42049e1e7b943cb491feb42d6550a498eed9121028b07
|
7
|
+
data.tar.gz: 7a8fe28722acbd2575a9ad53836463603b04916ffb544c5c4aea8a14e42b76398fce4644a29297a5a2cd02340a25afd1a1ba5b0a79a00e04efacae99078556c1
|
data/lib/mayak/monads/README.md
CHANGED
@@ -98,33 +98,47 @@ divide(10, 2).value_or(0) # 5
|
|
98
98
|
divide(10, 0).value_or(0) # 0
|
99
99
|
```
|
100
100
|
|
101
|
-
|
102
|
-
|
103
|
-
#### `#to_dry`
|
104
|
-
|
105
|
-
Converts an instance of a monad in to an instance of corresponding dry-monad.
|
106
|
-
|
101
|
+
Note that the type of value passed into `value_or` shouldn't necessarily be of the same type as `Maybe`. If it doesn't match
|
102
|
+
the result type of method invokation will be union of `Maybe` type and type of value passed:
|
107
103
|
```ruby
|
108
|
-
|
104
|
+
result = divide(10, 2).value_or("None")
|
105
|
+
T.reveal_type(result) # T.any(String, Integer)
|
106
|
+
```
|
109
107
|
|
110
|
-
|
111
|
-
|
108
|
+
You can also pass `nil` into `value_or`, and the result type of the expression will `T.nilable` type:
|
109
|
+
```ruby
|
110
|
+
result = divide(10, 2).value_or(nil)
|
111
|
+
T.reveal_type(result) # T.nilable(Integer)
|
112
112
|
```
|
113
113
|
|
114
|
-
|
114
|
+
### Methods
|
115
|
+
|
116
|
+
#### `#either`
|
115
117
|
|
116
|
-
|
118
|
+
Receives two lambda functions representing branches: none-branch, and some-branch. If a `Maybe` is `None` than none-branch will be executedand result of method invokation will be a result of none-branch execution. If a `Maybe` is `Some` than some-branch will be executed with a value of monad and result of method invokation will be a result of some-branch execution.
|
117
119
|
|
118
120
|
```ruby
|
119
|
-
|
121
|
+
divide(10, 2).either(
|
122
|
+
-> { 0 },
|
123
|
+
-> (value) { value * 100 }
|
124
|
+
) # 50
|
120
125
|
|
121
|
-
|
122
|
-
|
126
|
+
|
127
|
+
divide(10, 0).either(
|
128
|
+
-> { 0 },
|
129
|
+
-> (value) { value * 100 }
|
130
|
+
) # 0
|
131
|
+
|
132
|
+
result = divide(10, 0).either(
|
133
|
+
-> { "Error" },
|
134
|
+
-> (value) { value * 100 }
|
135
|
+
)
|
136
|
+
T.reveal_type(result) # T.any(String, Integer)
|
123
137
|
```
|
124
138
|
|
125
139
|
#### `#map`
|
126
140
|
|
127
|
-
The same as `fmap` in a dry-monads `Maybe`. Allows to modify the value with a block if it's present.
|
141
|
+
The same as `fmap` in a dry-monads `Maybe`. Allows to modify the value inside the `Maybe` with a block if it's present. Returns `Maybe` itself.
|
128
142
|
|
129
143
|
```ruby
|
130
144
|
sig { returns(Mayak::Monads::Maybe[Integer]) }
|
@@ -621,33 +635,6 @@ Try { raise "Boom" }.failure_or(StandardError.new("Error")) # #<StandardError: B
|
|
621
635
|
|
622
636
|
### Methods
|
623
637
|
|
624
|
-
#### `#to_dry`
|
625
|
-
|
626
|
-
Converts an instance of a monad in to an instance of corresponding dry-monad.
|
627
|
-
|
628
|
-
```ruby
|
629
|
-
include Mayak::Monads::Try::Mixin
|
630
|
-
|
631
|
-
Try { 10 }.to_dry # Try::Value(10)
|
632
|
-
Try { raise "Error" }.to_dry # Try::Error(RuntimeError: Error)
|
633
|
-
```
|
634
|
-
|
635
|
-
|
636
|
-
#### `.from_dry`
|
637
|
-
|
638
|
-
Converts instance of `Dry::Monads::Try` into instance `Mayak::Monads::Try`
|
639
|
-
|
640
|
-
```ruby
|
641
|
-
include Mayak::Monads
|
642
|
-
|
643
|
-
error = StandardError.new("Error")
|
644
|
-
Try.from_dry(Dry::Monads::Try::Value.new([StandardError], 10)) # Try::Success[T.untyped](value = 10)
|
645
|
-
Try.from_dry(Dry::Monads::Try::Error.new(error)) # Try::Failure[T.untyped](error=#<StandardError: Error>)
|
646
|
-
```
|
647
|
-
|
648
|
-
Unfortunately `.from_dry` doesn't preserve types due to the way `Dry::Monads::Try` is written, so
|
649
|
-
this method always returns `Mayak::Monads::Try[T.untyped]`.
|
650
|
-
|
651
638
|
#### `#map`
|
652
639
|
|
653
640
|
The same as `fmap` in a dry-monads `Try`. Allows to modify the value with a block if it's present.
|
@@ -1088,38 +1075,6 @@ Result::Failure[String, Integer].new("Error").failure_or("Another Error") # "Err
|
|
1088
1075
|
|
1089
1076
|
### Methods
|
1090
1077
|
|
1091
|
-
#### `#to_dry`
|
1092
|
-
|
1093
|
-
Converts an instance of a monad in to an instance of corresponding dry-monad.
|
1094
|
-
|
1095
|
-
```ruby
|
1096
|
-
Result::Success[String, Integer].new(10).to_dry # Success(10): Dry::Monads::Result::Success
|
1097
|
-
Result::Failure[String, Integer].new("Error").to_dry # Failure("Error"): Dry::Monads::Result::Failure
|
1098
|
-
```
|
1099
|
-
|
1100
|
-
|
1101
|
-
#### `.from_dry`
|
1102
|
-
|
1103
|
-
Converts instance of `Dry::Monads::Result` into instance `Mayak::Monads::Result`
|
1104
|
-
|
1105
|
-
```ruby
|
1106
|
-
sig { returns(Dry::Monads::Result::Success[String, Integer]) }
|
1107
|
-
def dry_success
|
1108
|
-
Dry::Monads::Result::Success.new(10)
|
1109
|
-
end
|
1110
|
-
|
1111
|
-
sig { returns(Dry::Monads::Result::Success[String, Integer]) }
|
1112
|
-
def dry_failure
|
1113
|
-
Dry::Monads::Result::Failure.new("Error")
|
1114
|
-
end
|
1115
|
-
|
1116
|
-
Try.from_dry(dry_success) # Mayak::Monads::Result::Success[String, Integer](value = 10)
|
1117
|
-
Try.from_dry(dry_failure) # Mayak::Monads::Result::Success[String, Integer]("Error")
|
1118
|
-
```
|
1119
|
-
|
1120
|
-
Unfortunately `.from_dry` doesn't preserve types due to the way `Dry::Monads::Try` is written, so
|
1121
|
-
this method always returns `Mayak::Monads::Try[T.untyped]`.
|
1122
|
-
|
1123
1078
|
#### `#map`
|
1124
1079
|
|
1125
1080
|
The same as `fmap` in a dry-monads `Result`. Allows to modify the value with a block if it's present.
|
data/lib/mayak/monads/maybe.rb
CHANGED
@@ -11,7 +11,7 @@ module Mayak
|
|
11
11
|
abstract!
|
12
12
|
sealed!
|
13
13
|
|
14
|
-
Value = type_member
|
14
|
+
Value = type_member(:out)
|
15
15
|
|
16
16
|
sig {
|
17
17
|
abstract
|
@@ -49,7 +49,12 @@ module Mayak
|
|
49
49
|
def none?
|
50
50
|
end
|
51
51
|
|
52
|
-
sig {
|
52
|
+
sig {
|
53
|
+
abstract
|
54
|
+
.type_parameters(:AnotherValue)
|
55
|
+
.params(value: T.type_parameter(:AnotherValue))
|
56
|
+
.returns(T.any(T.type_parameter(:AnotherValue), Value))
|
57
|
+
}
|
53
58
|
def value_or(value)
|
54
59
|
end
|
55
60
|
|
@@ -63,11 +68,13 @@ module Mayak
|
|
63
68
|
|
64
69
|
sig {
|
65
70
|
abstract
|
66
|
-
.type_parameters(:
|
67
|
-
.params(
|
68
|
-
|
71
|
+
.type_parameters(:NoneResult, :SomeResult)
|
72
|
+
.params(
|
73
|
+
none_branch: T.proc.returns(T.type_parameter(:NoneResult)),
|
74
|
+
some_branch: T.proc.params(arg0: Value).returns(T.type_parameter(:SomeResult))
|
75
|
+
).returns(T.any(T.type_parameter(:NoneResult), T.type_parameter(:SomeResult)))
|
69
76
|
}
|
70
|
-
def either(
|
77
|
+
def either(none_branch, some_branch)
|
71
78
|
end
|
72
79
|
|
73
80
|
sig {
|
@@ -92,10 +99,24 @@ module Mayak
|
|
92
99
|
map { |_| new_value }
|
93
100
|
end
|
94
101
|
|
95
|
-
sig {
|
102
|
+
sig {
|
103
|
+
type_parameters(:NewValue)
|
104
|
+
.abstract
|
105
|
+
.params(value: T.type_parameter(:NewValue))
|
106
|
+
.returns(Maybe[T.any(T.type_parameter(:NewValue), Value)])
|
107
|
+
}
|
96
108
|
def recover(value)
|
97
109
|
end
|
98
110
|
|
111
|
+
sig {
|
112
|
+
type_parameters(:NewValue)
|
113
|
+
.abstract
|
114
|
+
.params(maybe: Maybe[T.type_parameter(:NewValue)])
|
115
|
+
.returns(Maybe[T.any(T.type_parameter(:NewValue), Value)])
|
116
|
+
}
|
117
|
+
def recover_with_maybe(maybe)
|
118
|
+
end
|
119
|
+
|
99
120
|
sig(:final) { params(another: Mayak::Monads::Maybe[T.untyped]).returns(T::Boolean) }
|
100
121
|
def ==(another)
|
101
122
|
case self
|
@@ -212,7 +233,12 @@ module Mayak
|
|
212
233
|
false
|
213
234
|
end
|
214
235
|
|
215
|
-
sig(:final) {
|
236
|
+
sig(:final) {
|
237
|
+
override
|
238
|
+
.type_parameters(:AnotherValue)
|
239
|
+
.params(value: T.any(T.type_parameter(:AnotherValue), Value))
|
240
|
+
.returns(T.any(T.type_parameter(:AnotherValue), Value))
|
241
|
+
}
|
216
242
|
def value_or(value)
|
217
243
|
@value
|
218
244
|
end
|
@@ -229,12 +255,14 @@ module Mayak
|
|
229
255
|
|
230
256
|
sig(:final) {
|
231
257
|
override
|
232
|
-
.type_parameters(:
|
233
|
-
.params(
|
234
|
-
|
258
|
+
.type_parameters(:NoneResult, :SomeResult)
|
259
|
+
.params(
|
260
|
+
none_branch: T.proc.returns(T.type_parameter(:NoneResult)),
|
261
|
+
some_branch: T.proc.params(arg0: Value).returns(T.type_parameter(:SomeResult))
|
262
|
+
).returns(T.any(T.type_parameter(:NoneResult), T.type_parameter(:SomeResult)))
|
235
263
|
}
|
236
|
-
def either(
|
237
|
-
|
264
|
+
def either(none_branch, some_branch)
|
265
|
+
some_branch.call(@value)
|
238
266
|
end
|
239
267
|
|
240
268
|
sig(:final) {
|
@@ -252,10 +280,25 @@ module Mayak
|
|
252
280
|
Mayak::Monads::Try::Success.new(@value)
|
253
281
|
end
|
254
282
|
|
255
|
-
sig(:final) {
|
283
|
+
sig(:final) {
|
284
|
+
type_parameters(:NewValue)
|
285
|
+
.override
|
286
|
+
.params(value: T.type_parameter(:NewValue))
|
287
|
+
.returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
|
288
|
+
}
|
256
289
|
def recover(value)
|
257
290
|
self
|
258
291
|
end
|
292
|
+
|
293
|
+
sig(:final) {
|
294
|
+
type_parameters(:NewValue)
|
295
|
+
.override
|
296
|
+
.params(maybe: Maybe[T.type_parameter(:NewValue)])
|
297
|
+
.returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
|
298
|
+
}
|
299
|
+
def recover_with_maybe(maybe)
|
300
|
+
self
|
301
|
+
end
|
259
302
|
end
|
260
303
|
|
261
304
|
class None
|
@@ -314,7 +357,12 @@ module Mayak
|
|
314
357
|
true
|
315
358
|
end
|
316
359
|
|
317
|
-
sig(:final) {
|
360
|
+
sig(:final) {
|
361
|
+
override
|
362
|
+
.type_parameters(:AnotherValue)
|
363
|
+
.params(value: T.any(T.type_parameter(:AnotherValue), Value))
|
364
|
+
.returns(T.any(T.type_parameter(:AnotherValue), Value))
|
365
|
+
}
|
318
366
|
def value_or(value)
|
319
367
|
value
|
320
368
|
end
|
@@ -330,12 +378,14 @@ module Mayak
|
|
330
378
|
|
331
379
|
sig(:final) {
|
332
380
|
override
|
333
|
-
.type_parameters(:
|
334
|
-
.params(
|
335
|
-
|
381
|
+
.type_parameters(:NoneResult, :SomeResult)
|
382
|
+
.params(
|
383
|
+
none_branch: T.proc.returns(T.type_parameter(:NoneResult)),
|
384
|
+
some_branch: T.proc.params(arg0: Value).returns(T.type_parameter(:SomeResult))
|
385
|
+
).returns(T.any(T.type_parameter(:NoneResult), T.type_parameter(:SomeResult)))
|
336
386
|
}
|
337
|
-
def either(
|
338
|
-
|
387
|
+
def either(none_branch, some_branch)
|
388
|
+
none_branch.call
|
339
389
|
end
|
340
390
|
|
341
391
|
sig(:final) {
|
@@ -353,10 +403,25 @@ module Mayak
|
|
353
403
|
Mayak::Monads::Try::Failure.new(error)
|
354
404
|
end
|
355
405
|
|
356
|
-
sig(:final) {
|
406
|
+
sig(:final) {
|
407
|
+
type_parameters(:NewValue)
|
408
|
+
.override
|
409
|
+
.params(value: T.type_parameter(:NewValue))
|
410
|
+
.returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
|
411
|
+
}
|
357
412
|
def recover(value)
|
358
413
|
Mayak::Monads::Maybe::Some.new(value)
|
359
414
|
end
|
415
|
+
|
416
|
+
sig(:final) {
|
417
|
+
type_parameters(:NewValue)
|
418
|
+
.override
|
419
|
+
.params(maybe: Maybe[T.type_parameter(:NewValue)])
|
420
|
+
.returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
|
421
|
+
}
|
422
|
+
def recover_with_maybe(maybe)
|
423
|
+
maybe
|
424
|
+
end
|
360
425
|
end
|
361
426
|
|
362
427
|
module Mixin
|
data/lib/mayak/monads/result.rb
CHANGED
@@ -11,8 +11,8 @@ module Mayak
|
|
11
11
|
abstract!
|
12
12
|
sealed!
|
13
13
|
|
14
|
-
FailureType = type_member
|
15
|
-
SuccessType = type_member
|
14
|
+
FailureType = type_member(:out)
|
15
|
+
SuccessType = type_member(:out)
|
16
16
|
|
17
17
|
sig {
|
18
18
|
abstract
|
@@ -24,20 +24,21 @@ module Mayak
|
|
24
24
|
end
|
25
25
|
|
26
26
|
sig {
|
27
|
-
|
28
|
-
.
|
27
|
+
type_parameters(:NewSuccess, :NewFailure)
|
28
|
+
.abstract
|
29
29
|
.params(
|
30
|
-
blk: T.proc.params(arg0: SuccessType).returns(Result[
|
30
|
+
blk: T.proc.params(arg0: SuccessType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
31
31
|
)
|
32
|
-
.returns(Result[FailureType, T.type_parameter(:NewSuccess)])
|
32
|
+
.returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), T.type_parameter(:NewSuccess)])
|
33
33
|
}
|
34
34
|
def flat_map(&blk)
|
35
35
|
end
|
36
36
|
|
37
37
|
sig {
|
38
|
-
|
39
|
-
.
|
40
|
-
.
|
38
|
+
type_parameters(:NewSuccess, :NewFailure)
|
39
|
+
.abstract
|
40
|
+
.params(error: T.type_parameter(:NewFailure), blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
|
41
|
+
.returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType])
|
41
42
|
}
|
42
43
|
def filter_or(error, &blk)
|
43
44
|
end
|
@@ -50,11 +51,21 @@ module Mayak
|
|
50
51
|
def failure?
|
51
52
|
end
|
52
53
|
|
53
|
-
sig {
|
54
|
+
sig {
|
55
|
+
abstract
|
56
|
+
.type_parameters(:NewSuccessType)
|
57
|
+
.params(value: T.type_parameter(:NewSuccessType))
|
58
|
+
.returns(T.any(T.type_parameter(:NewSuccessType), SuccessType))
|
59
|
+
}
|
54
60
|
def success_or(value)
|
55
61
|
end
|
56
62
|
|
57
|
-
sig {
|
63
|
+
sig {
|
64
|
+
abstract
|
65
|
+
.type_parameters(:NewFailureType)
|
66
|
+
.params(value: T.type_parameter(:NewFailureType))
|
67
|
+
.returns(T.any(T.type_parameter(:NewFailureType), FailureType))
|
68
|
+
}
|
58
69
|
def failure_or(value)
|
59
70
|
end
|
60
71
|
|
@@ -118,11 +129,11 @@ module Mayak
|
|
118
129
|
|
119
130
|
sig {
|
120
131
|
abstract
|
121
|
-
.type_parameters(:NewFailure)
|
132
|
+
.type_parameters(:NewFailure, :NewSuccess)
|
122
133
|
.params(
|
123
|
-
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure),
|
134
|
+
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
124
135
|
).returns(
|
125
|
-
Result[T.type_parameter(:NewFailure), SuccessType]
|
136
|
+
Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
|
126
137
|
)
|
127
138
|
}
|
128
139
|
def flat_map_failure(&blk)
|
@@ -158,28 +169,30 @@ module Mayak
|
|
158
169
|
end
|
159
170
|
|
160
171
|
sig {
|
161
|
-
|
162
|
-
.
|
163
|
-
.
|
172
|
+
type_parameters(:NewSuccess)
|
173
|
+
.abstract
|
174
|
+
.params(value: T.type_parameter(:NewSuccess))
|
175
|
+
.returns(Result[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)])
|
164
176
|
}
|
165
177
|
def recover(value)
|
166
178
|
end
|
167
179
|
|
168
180
|
sig {
|
169
|
-
|
170
|
-
.
|
171
|
-
.
|
181
|
+
type_parameters(:NewSuccessType)
|
182
|
+
.abstract
|
183
|
+
.params(blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewSuccessType)))
|
184
|
+
.returns(Result[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))])
|
172
185
|
}
|
173
186
|
def recover_with(&blk)
|
174
187
|
end
|
175
188
|
|
176
189
|
sig {
|
177
190
|
abstract
|
178
|
-
.type_parameters(:NewFailure)
|
191
|
+
.type_parameters(:NewFailure, :NewSuccess)
|
179
192
|
.params(
|
180
|
-
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure),
|
193
|
+
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
181
194
|
).returns(
|
182
|
-
Result[T.type_parameter(:NewFailure), SuccessType]
|
195
|
+
Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
|
183
196
|
)
|
184
197
|
}
|
185
198
|
def recover_with_result(&blk)
|
@@ -237,28 +250,30 @@ module Mayak
|
|
237
250
|
Mayak::Monads::Result::Success.new(blk.call(@success_value))
|
238
251
|
end
|
239
252
|
|
253
|
+
|
240
254
|
sig(:final) {
|
241
255
|
override
|
242
|
-
.type_parameters(:NewSuccess)
|
256
|
+
.type_parameters(:NewSuccess, :NewFailure)
|
243
257
|
.params(
|
244
|
-
blk: T.proc.params(arg0: SuccessType).returns(Result[
|
258
|
+
blk: T.proc.params(arg0: SuccessType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
245
259
|
)
|
246
|
-
.returns(Result[FailureType, T.type_parameter(:NewSuccess)])
|
260
|
+
.returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), T.type_parameter(:NewSuccess)])
|
247
261
|
}
|
248
262
|
def flat_map(&blk)
|
249
263
|
blk.call(@success_value)
|
250
264
|
end
|
251
265
|
|
252
266
|
sig(:final) {
|
253
|
-
|
254
|
-
.
|
255
|
-
.
|
267
|
+
type_parameters(:NewSuccess, :NewFailure)
|
268
|
+
.override
|
269
|
+
.params(error: T.type_parameter(:NewFailure), blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
|
270
|
+
.returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType])
|
256
271
|
}
|
257
272
|
def filter_or(error, &blk)
|
258
273
|
if blk.call(@success_value)
|
259
274
|
self
|
260
275
|
else
|
261
|
-
Mayak::Monads::Result::Failure[FailureType, SuccessType].new(error)
|
276
|
+
::Mayak::Monads::Result::Failure[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType].new(error)
|
262
277
|
end
|
263
278
|
end
|
264
279
|
|
@@ -277,12 +292,22 @@ module Mayak
|
|
277
292
|
false
|
278
293
|
end
|
279
294
|
|
280
|
-
sig(:final) {
|
295
|
+
sig(:final) {
|
296
|
+
override
|
297
|
+
.type_parameters(:NewSuccessType)
|
298
|
+
.params(value: T.type_parameter(:NewSuccessType))
|
299
|
+
.returns(T.any(T.type_parameter(:NewSuccessType), SuccessType))
|
300
|
+
}
|
281
301
|
def success_or(value)
|
282
302
|
@success_value
|
283
303
|
end
|
284
304
|
|
285
|
-
sig(:final) {
|
305
|
+
sig(:final) {
|
306
|
+
override
|
307
|
+
.type_parameters(:NewFailureType)
|
308
|
+
.params(value: T.any(T.type_parameter(:NewFailureType), FailureType))
|
309
|
+
.returns(T.any(T.type_parameter(:NewFailureType), FailureType))
|
310
|
+
}
|
286
311
|
def failure_or(value)
|
287
312
|
value
|
288
313
|
end
|
@@ -347,12 +372,12 @@ module Mayak
|
|
347
372
|
end
|
348
373
|
|
349
374
|
sig(:final) {
|
350
|
-
|
351
|
-
.
|
375
|
+
type_parameters(:NewFailure, :NewSuccess)
|
376
|
+
.override
|
352
377
|
.params(
|
353
|
-
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure),
|
378
|
+
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
354
379
|
).returns(
|
355
|
-
Result[T.type_parameter(:NewFailure), SuccessType]
|
380
|
+
Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
|
356
381
|
)
|
357
382
|
}
|
358
383
|
def flat_map_failure(&blk)
|
@@ -363,28 +388,33 @@ module Mayak
|
|
363
388
|
end
|
364
389
|
|
365
390
|
sig(:final) {
|
366
|
-
|
367
|
-
.
|
368
|
-
.
|
391
|
+
type_parameters(:NewSuccess)
|
392
|
+
.override
|
393
|
+
.params(value: T.type_parameter(:NewSuccess))
|
394
|
+
.returns(Result[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)])
|
369
395
|
}
|
370
396
|
def recover(value)
|
371
397
|
self
|
372
398
|
end
|
373
399
|
|
374
400
|
sig(:final) {
|
375
|
-
|
376
|
-
.
|
377
|
-
.
|
401
|
+
type_parameters(:NewSuccessType)
|
402
|
+
.override
|
403
|
+
.params(blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewSuccessType)))
|
404
|
+
.returns(Result[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))])
|
378
405
|
}
|
379
406
|
def recover_with(&blk)
|
380
407
|
self
|
381
408
|
end
|
382
409
|
|
383
410
|
sig(:final) {
|
384
|
-
|
385
|
-
.
|
386
|
-
.params(
|
387
|
-
|
411
|
+
type_parameters(:NewFailure, :NewSuccess)
|
412
|
+
.override
|
413
|
+
.params(
|
414
|
+
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
415
|
+
).returns(
|
416
|
+
Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
|
417
|
+
)
|
388
418
|
}
|
389
419
|
def recover_with_result(&blk)
|
390
420
|
T.cast(
|
@@ -426,11 +456,11 @@ module Mayak
|
|
426
456
|
|
427
457
|
sig(:final) {
|
428
458
|
override
|
429
|
-
.type_parameters(:NewSuccess)
|
459
|
+
.type_parameters(:NewSuccess, :NewFailure)
|
430
460
|
.params(
|
431
|
-
blk: T.proc.params(arg0: SuccessType).returns(Result[
|
461
|
+
blk: T.proc.params(arg0: SuccessType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
432
462
|
)
|
433
|
-
.returns(Result[FailureType, T.type_parameter(:NewSuccess)])
|
463
|
+
.returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), T.type_parameter(:NewSuccess)])
|
434
464
|
}
|
435
465
|
def flat_map(&blk)
|
436
466
|
T.cast(
|
@@ -440,9 +470,10 @@ module Mayak
|
|
440
470
|
end
|
441
471
|
|
442
472
|
sig(:final) {
|
443
|
-
|
444
|
-
.
|
445
|
-
.
|
473
|
+
type_parameters(:NewSuccess, :NewFailure)
|
474
|
+
.override
|
475
|
+
.params(error: T.type_parameter(:NewFailure), blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
|
476
|
+
.returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType])
|
446
477
|
}
|
447
478
|
def filter_or(error, &blk)
|
448
479
|
self
|
@@ -463,12 +494,22 @@ module Mayak
|
|
463
494
|
true
|
464
495
|
end
|
465
496
|
|
466
|
-
sig(:final) {
|
497
|
+
sig(:final) {
|
498
|
+
override
|
499
|
+
.type_parameters(:NewSuccessType)
|
500
|
+
.params(value: T.type_parameter(:NewSuccessType))
|
501
|
+
.returns(T.any(T.type_parameter(:NewSuccessType), SuccessType))
|
502
|
+
}
|
467
503
|
def success_or(value)
|
468
504
|
value
|
469
505
|
end
|
470
506
|
|
471
|
-
sig(:final) {
|
507
|
+
sig(:final) {
|
508
|
+
override
|
509
|
+
.type_parameters(:NewFailureType)
|
510
|
+
.params(value: T.any(T.type_parameter(:NewFailureType), FailureType))
|
511
|
+
.returns(T.any(T.type_parameter(:NewFailureType), FailureType))
|
512
|
+
}
|
472
513
|
def failure_or(value)
|
473
514
|
@failure_value
|
474
515
|
end
|
@@ -529,12 +570,12 @@ module Mayak
|
|
529
570
|
end
|
530
571
|
|
531
572
|
sig(:final) {
|
532
|
-
|
533
|
-
.
|
573
|
+
type_parameters(:NewFailure, :NewSuccess)
|
574
|
+
.override
|
534
575
|
.params(
|
535
|
-
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure),
|
576
|
+
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
536
577
|
).returns(
|
537
|
-
Result[T.type_parameter(:NewFailure), SuccessType]
|
578
|
+
Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
|
538
579
|
)
|
539
580
|
}
|
540
581
|
def flat_map_failure(&blk)
|
@@ -542,28 +583,36 @@ module Mayak
|
|
542
583
|
end
|
543
584
|
|
544
585
|
sig(:final) {
|
545
|
-
|
546
|
-
.
|
547
|
-
.
|
586
|
+
type_parameters(:NewSuccess)
|
587
|
+
.override
|
588
|
+
.params(value: T.type_parameter(:NewSuccess))
|
589
|
+
.returns(Result[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)])
|
548
590
|
}
|
549
591
|
def recover(value)
|
550
|
-
Mayak::Monads::Result::Success[FailureType, SuccessType].new(value)
|
592
|
+
::Mayak::Monads::Result::Success[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)].new(value)
|
551
593
|
end
|
552
594
|
|
595
|
+
|
553
596
|
sig(:final) {
|
554
|
-
|
555
|
-
.
|
556
|
-
.
|
597
|
+
type_parameters(:NewSuccessType)
|
598
|
+
.override
|
599
|
+
.params(blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewSuccessType)))
|
600
|
+
.returns(Result[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))])
|
557
601
|
}
|
558
602
|
def recover_with(&blk)
|
559
|
-
Mayak::Monads::Result::Success[FailureType,
|
603
|
+
::Mayak::Monads::Result::Success[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))].new(
|
604
|
+
blk.call(@failure_value)
|
605
|
+
)
|
560
606
|
end
|
561
607
|
|
562
608
|
sig(:final) {
|
563
|
-
|
564
|
-
.
|
565
|
-
.params(
|
566
|
-
|
609
|
+
type_parameters(:NewFailure, :NewSuccess)
|
610
|
+
.override
|
611
|
+
.params(
|
612
|
+
blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
|
613
|
+
).returns(
|
614
|
+
Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
|
615
|
+
)
|
567
616
|
}
|
568
617
|
def recover_with_result(&blk)
|
569
618
|
blk.call(@failure_value)
|
data/lib/mayak/monads/try.rb
CHANGED
@@ -10,7 +10,7 @@ module Mayak
|
|
10
10
|
abstract!
|
11
11
|
sealed!
|
12
12
|
|
13
|
-
Value = type_member
|
13
|
+
Value = type_member(:out)
|
14
14
|
|
15
15
|
sig {
|
16
16
|
abstract
|
@@ -48,7 +48,12 @@ module Mayak
|
|
48
48
|
def failure?
|
49
49
|
end
|
50
50
|
|
51
|
-
sig {
|
51
|
+
sig {
|
52
|
+
abstract
|
53
|
+
.type_parameters(:NewValue)
|
54
|
+
.params(value: T.type_parameter(:NewValue))
|
55
|
+
.returns(T.any(T.type_parameter(:NewValue), Value))
|
56
|
+
}
|
52
57
|
def success_or(value)
|
53
58
|
end
|
54
59
|
|
@@ -86,9 +91,10 @@ module Mayak
|
|
86
91
|
end
|
87
92
|
|
88
93
|
sig {
|
89
|
-
|
90
|
-
.
|
91
|
-
.returns(Try[
|
94
|
+
type_parameters(:NewValue)
|
95
|
+
.abstract
|
96
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
|
97
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
92
98
|
}
|
93
99
|
def flat_map_failure(&blk)
|
94
100
|
end
|
@@ -141,34 +147,39 @@ module Mayak
|
|
141
147
|
end
|
142
148
|
|
143
149
|
sig {
|
144
|
-
|
145
|
-
.
|
146
|
-
.
|
150
|
+
type_parameters(:NewValue)
|
151
|
+
.abstract
|
152
|
+
.params(value: T.type_parameter(:NewValue))
|
153
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
147
154
|
}
|
148
155
|
def recover(value)
|
149
156
|
end
|
150
157
|
|
151
158
|
sig {
|
152
|
-
|
153
|
-
.
|
154
|
-
.returns(
|
159
|
+
type_parameters(:NewValue)
|
160
|
+
.abstract
|
161
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue)))
|
162
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
155
163
|
}
|
156
164
|
def recover_with(&blk)
|
157
165
|
end
|
158
166
|
|
159
167
|
sig {
|
160
|
-
|
168
|
+
type_parameters(:NewValue)
|
169
|
+
.abstract
|
161
170
|
.params(
|
162
171
|
error_type: T.class_of(StandardError),
|
163
|
-
blk: T.proc.params(arg0: StandardError).returns(
|
172
|
+
blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue))
|
164
173
|
)
|
165
|
-
.returns(Try[Value])
|
174
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
166
175
|
}
|
167
176
|
def recover_on(error_type, &blk)
|
168
177
|
end
|
169
178
|
|
170
179
|
sig(:final) {
|
171
|
-
|
180
|
+
type_parameters(:NewValue)
|
181
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
|
182
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
172
183
|
}
|
173
184
|
def recover_with_try(&blk)
|
174
185
|
flat_map_failure(&blk)
|
@@ -272,7 +283,12 @@ module Mayak
|
|
272
283
|
false
|
273
284
|
end
|
274
285
|
|
275
|
-
sig(:final) {
|
286
|
+
sig(:final) {
|
287
|
+
override
|
288
|
+
.type_parameters(:NewValue)
|
289
|
+
.params(value: T.any(T.type_parameter(:NewValue), Value))
|
290
|
+
.returns(T.any(T.type_parameter(:NewValue), Value))
|
291
|
+
}
|
276
292
|
def success_or(value)
|
277
293
|
@value
|
278
294
|
end
|
@@ -316,9 +332,10 @@ module Mayak
|
|
316
332
|
end
|
317
333
|
|
318
334
|
sig(:final) {
|
319
|
-
|
320
|
-
.
|
321
|
-
.returns(Try[
|
335
|
+
type_parameters(:NewValue)
|
336
|
+
.override
|
337
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
|
338
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
322
339
|
}
|
323
340
|
def flat_map_failure(&blk)
|
324
341
|
self
|
@@ -340,27 +357,34 @@ module Mayak
|
|
340
357
|
end
|
341
358
|
|
342
359
|
sig(:final) {
|
343
|
-
|
360
|
+
type_parameters(:NewValue)
|
361
|
+
.override
|
344
362
|
.params(
|
345
363
|
error_type: T.class_of(StandardError),
|
346
|
-
blk: T.proc.params(arg0: StandardError).returns(
|
364
|
+
blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue))
|
347
365
|
)
|
348
|
-
.returns(Try[Value])
|
366
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
349
367
|
}
|
350
368
|
def recover_on(error_type, &blk)
|
351
369
|
self
|
352
370
|
end
|
353
371
|
|
354
372
|
sig(:final) {
|
355
|
-
|
356
|
-
.
|
357
|
-
.
|
373
|
+
type_parameters(:NewValue)
|
374
|
+
.override
|
375
|
+
.params(value: T.type_parameter(:NewValue))
|
376
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
358
377
|
}
|
359
378
|
def recover(value)
|
360
379
|
self
|
361
380
|
end
|
362
381
|
|
363
|
-
sig(:final) {
|
382
|
+
sig(:final) {
|
383
|
+
type_parameters(:NewValue)
|
384
|
+
.override
|
385
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue)))
|
386
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
387
|
+
}
|
364
388
|
def recover_with(&blk)
|
365
389
|
self
|
366
390
|
end
|
@@ -431,7 +455,12 @@ module Mayak
|
|
431
455
|
true
|
432
456
|
end
|
433
457
|
|
434
|
-
sig(:final) {
|
458
|
+
sig(:final) {
|
459
|
+
override
|
460
|
+
.type_parameters(:NewValue)
|
461
|
+
.params(value: T.any(T.type_parameter(:NewValue), Value))
|
462
|
+
.returns(T.any(T.type_parameter(:NewValue), Value))
|
463
|
+
}
|
435
464
|
def success_or(value)
|
436
465
|
value
|
437
466
|
end
|
@@ -474,9 +503,10 @@ module Mayak
|
|
474
503
|
end
|
475
504
|
|
476
505
|
sig(:final) {
|
477
|
-
|
478
|
-
.
|
479
|
-
.returns(Try[
|
506
|
+
type_parameters(:NewValue)
|
507
|
+
.override
|
508
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
|
509
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
480
510
|
}
|
481
511
|
def flat_map_failure(&blk)
|
482
512
|
blk.call(@failure)
|
@@ -494,37 +524,44 @@ module Mayak
|
|
494
524
|
|
495
525
|
sig(:final) { override.returns(Mayak::Monads::Maybe[Value]) }
|
496
526
|
def to_maybe
|
497
|
-
Mayak::Monads::Maybe::None.new
|
527
|
+
::Mayak::Monads::Maybe::None[Value].new
|
498
528
|
end
|
499
529
|
|
500
530
|
sig(:final) {
|
501
|
-
|
531
|
+
type_parameters(:NewValue)
|
532
|
+
.override
|
502
533
|
.params(
|
503
534
|
error_type: T.class_of(StandardError),
|
504
|
-
blk: T.proc.params(arg0: StandardError).returns(
|
535
|
+
blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue))
|
505
536
|
)
|
506
|
-
.returns(Try[Value])
|
537
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
507
538
|
}
|
508
539
|
def recover_on(error_type, &blk)
|
509
540
|
if @failure.is_a?(error_type)
|
510
|
-
Mayak::Monads::Try::Success[Value].new(blk.call(@failure))
|
541
|
+
::Mayak::Monads::Try::Success[T.any(T.type_parameter(:NewValue), Value)].new(blk.call(@failure))
|
511
542
|
else
|
512
543
|
self
|
513
544
|
end
|
514
545
|
end
|
515
546
|
|
516
547
|
sig(:final) {
|
517
|
-
|
518
|
-
.
|
519
|
-
.
|
548
|
+
type_parameters(:NewValue)
|
549
|
+
.override
|
550
|
+
.params(value: T.type_parameter(:NewValue))
|
551
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
520
552
|
}
|
521
553
|
def recover(value)
|
522
|
-
Mayak::Monads::Try::Success[Value].new(value)
|
554
|
+
::Mayak::Monads::Try::Success[T.any(T.type_parameter(:NewValue), Value)].new(value)
|
523
555
|
end
|
524
556
|
|
525
|
-
sig(:final) {
|
557
|
+
sig(:final) {
|
558
|
+
type_parameters(:NewValue)
|
559
|
+
.override
|
560
|
+
.params(blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue)))
|
561
|
+
.returns(Try[T.any(T.type_parameter(:NewValue), Value)])
|
562
|
+
}
|
526
563
|
def recover_with(&blk)
|
527
|
-
Mayak::Monads::Try::Success[Value].new(blk.call(@failure))
|
564
|
+
::Mayak::Monads::Try::Success[T.any(T.type_parameter(:NewValue), Value)].new(blk.call(@failure))
|
528
565
|
end
|
529
566
|
end
|
530
567
|
|
data/mayak.gemspec
CHANGED
@@ -4,7 +4,7 @@
|
|
4
4
|
|
5
5
|
Gem::Specification.new do |spec|
|
6
6
|
spec.name = "mayak"
|
7
|
-
spec.version = "0.0.
|
7
|
+
spec.version = "0.0.5"
|
8
8
|
spec.summary = "Set of fully typed utility classes and interfaces integrated with Sorbet."
|
9
9
|
spec.description = spec.summary
|
10
10
|
spec.authors = ["Daniil Bober"]
|
metadata
CHANGED
@@ -1,14 +1,14 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: mayak
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 0.0.
|
4
|
+
version: 0.0.5
|
5
5
|
platform: ruby
|
6
6
|
authors:
|
7
7
|
- Daniil Bober
|
8
8
|
autorequire:
|
9
9
|
bindir: bin
|
10
10
|
cert_chain: []
|
11
|
-
date: 2024-
|
11
|
+
date: 2024-03-27 00:00:00.000000000 Z
|
12
12
|
dependencies:
|
13
13
|
- !ruby/object:Gem::Dependency
|
14
14
|
name: sorbet-runtime
|