mayak 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,574 @@
1
+ # frozen_string_literal: true
2
+ # typed: strict
3
+
4
+ module Mayak
5
+ module Monads
6
+ module Result
7
+ extend T::Sig
8
+ extend T::Generic
9
+ extend T::Helpers
10
+
11
+ abstract!
12
+ sealed!
13
+
14
+ FailureType = type_member
15
+ SuccessType = type_member
16
+
17
+ sig {
18
+ abstract
19
+ .type_parameters(:NewSuccess)
20
+ .params(blk: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:NewSuccess)))
21
+ .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
22
+ }
23
+ def map(&blk)
24
+ end
25
+
26
+ sig {
27
+ abstract
28
+ .type_parameters(:NewSuccess)
29
+ .params(
30
+ blk: T.proc.params(arg0: SuccessType).returns(Result[FailureType, T.type_parameter(:NewSuccess)])
31
+ )
32
+ .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
33
+ }
34
+ def flat_map(&blk)
35
+ end
36
+
37
+ sig {
38
+ abstract
39
+ .params(error: FailureType, blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
40
+ .returns(Result[FailureType, SuccessType])
41
+ }
42
+ def filter_or(error, &blk)
43
+ end
44
+
45
+ sig { abstract.returns(T::Boolean) }
46
+ def success?
47
+ end
48
+
49
+ sig { abstract.returns(T::Boolean) }
50
+ def failure?
51
+ end
52
+
53
+ sig { abstract.params(value: SuccessType).returns(SuccessType) }
54
+ def success_or(value)
55
+ end
56
+
57
+ sig { abstract.params(value: FailureType).returns(FailureType) }
58
+ def failure_or(value)
59
+ end
60
+
61
+ sig { abstract.returns(Result[SuccessType, FailureType]) }
62
+ def flip
63
+ end
64
+
65
+ sig {
66
+ abstract
67
+ .params(blk: T.proc.params(arg0: FailureType).returns(StandardError))
68
+ .returns(Mayak::Monads::Try[SuccessType])
69
+ }
70
+ def to_try(&blk)
71
+ end
72
+
73
+ sig { abstract.returns(Mayak::Monads::Maybe[SuccessType]) }
74
+ def to_maybe
75
+ end
76
+
77
+ sig {
78
+ abstract
79
+ .type_parameters(:Result)
80
+ .params(
81
+ failure_branch: T.proc.params(arg0: FailureType).returns(T.type_parameter(:Result)),
82
+ success_branch: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:Result))
83
+ ).returns(
84
+ T.type_parameter(:Result)
85
+ )
86
+ }
87
+ def either(failure_branch, success_branch)
88
+ end
89
+
90
+ sig(:final) {
91
+ type_parameters(:NewFailure)
92
+ .params(new_failure: T.type_parameter(:NewFailure))
93
+ .returns(Result[T.type_parameter(:NewFailure), SuccessType])
94
+ }
95
+ def failure_as(new_failure)
96
+ map_failure { |_| new_failure }
97
+ end
98
+
99
+ sig {
100
+ abstract
101
+ .params(blk: T.proc.params(arg0: SuccessType).void)
102
+ .returns(Result[FailureType, SuccessType])
103
+ }
104
+ def tee(&blk)
105
+ end
106
+
107
+ sig {
108
+ abstract
109
+ .type_parameters(:NewFailure)
110
+ .params(
111
+ blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewFailure))
112
+ ).returns(
113
+ Result[T.type_parameter(:NewFailure), SuccessType]
114
+ )
115
+ }
116
+ def map_failure(&blk)
117
+ end
118
+
119
+ sig {
120
+ abstract
121
+ .type_parameters(:NewFailure)
122
+ .params(
123
+ blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
124
+ ).returns(
125
+ Result[T.type_parameter(:NewFailure), SuccessType]
126
+ )
127
+ }
128
+ def flat_map_failure(&blk)
129
+ end
130
+
131
+ sig(:final) { params(another: Mayak::Monads::Result[T.untyped, T.untyped]).returns(T::Boolean) }
132
+ def ==(another)
133
+ case self
134
+ when Mayak::Monads::Result::Success
135
+ case another
136
+ when Mayak::Monads::Result::Success then T.unsafe(success) == another.success
137
+ when Mayak::Monads::Result::Failure then false
138
+ else T.absurd(another)
139
+ end
140
+ when Mayak::Monads::Result::Failure
141
+ case another
142
+ when Mayak::Monads::Result::Success then false
143
+ when Mayak::Monads::Result::Failure then T.unsafe(failure) == another.failure
144
+ else T.absurd(another)
145
+ end
146
+ else
147
+ T.absurd(self)
148
+ end
149
+ end
150
+
151
+ sig(:final) {
152
+ type_parameters(:NewValue)
153
+ .params(new_value: T.type_parameter(:NewValue))
154
+ .returns(Result[FailureType, T.type_parameter(:NewValue)])
155
+ }
156
+ def as(new_value)
157
+ map { |_| new_value }
158
+ end
159
+
160
+ sig {
161
+ abstract
162
+ .params(value: SuccessType)
163
+ .returns(Result[FailureType, SuccessType])
164
+ }
165
+ def recover(value)
166
+ end
167
+
168
+ sig {
169
+ abstract
170
+ .params(blk: T.proc.params(arg0: FailureType).returns(SuccessType))
171
+ .returns(Result[FailureType, SuccessType])
172
+ }
173
+ def recover_with(&blk)
174
+ end
175
+
176
+ sig {
177
+ abstract
178
+ .type_parameters(:NewFailure)
179
+ .params(
180
+ blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
181
+ ).returns(
182
+ Result[T.type_parameter(:NewFailure), SuccessType]
183
+ )
184
+ }
185
+ def recover_with_result(&blk)
186
+ end
187
+
188
+ sig {
189
+ type_parameters(:SuccessType, :FailureType)
190
+ .params(
191
+ results: T::Array[
192
+ Mayak::Monads::Result[
193
+ T.type_parameter(:FailureType),
194
+ T.type_parameter(:SuccessType)
195
+ ]
196
+ ]
197
+ ).returns(
198
+ Mayak::Monads::Result[
199
+ T.type_parameter(:FailureType),
200
+ T::Array[T.type_parameter(:SuccessType)]
201
+ ]
202
+ )
203
+ }
204
+ def self.sequence(results)
205
+ init = Success[T.type_parameter(:FailureType), T::Array[T.type_parameter(:SuccessType)]].new([])
206
+ results.reduce(init) do |result, element|
207
+ result.flat_map do |array|
208
+ element.map { |value| array + [value] }
209
+ end
210
+ end
211
+ end
212
+
213
+ class Success
214
+ extend T::Sig
215
+ extend T::Generic
216
+ extend T::Helpers
217
+
218
+ final!
219
+
220
+ FailureType = type_member
221
+ SuccessType = type_member
222
+
223
+ include Mayak::Monads::Result
224
+
225
+ sig(:final) { params(value: SuccessType).void }
226
+ def initialize(value)
227
+ @success_value = T.let(value, SuccessType)
228
+ end
229
+
230
+ sig(:final) {
231
+ override
232
+ .type_parameters(:NewSuccess)
233
+ .params(blk: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:NewSuccess)))
234
+ .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
235
+ }
236
+ def map(&blk)
237
+ Mayak::Monads::Result::Success.new(blk.call(@success_value))
238
+ end
239
+
240
+ sig(:final) {
241
+ override
242
+ .type_parameters(:NewSuccess)
243
+ .params(
244
+ blk: T.proc.params(arg0: SuccessType).returns(Result[FailureType, T.type_parameter(:NewSuccess)])
245
+ )
246
+ .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
247
+ }
248
+ def flat_map(&blk)
249
+ blk.call(@success_value)
250
+ end
251
+
252
+ sig(:final) {
253
+ override
254
+ .params(error: FailureType, blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
255
+ .returns(Result[FailureType, SuccessType])
256
+ }
257
+ def filter_or(error, &blk)
258
+ if blk.call(@success_value)
259
+ self
260
+ else
261
+ Mayak::Monads::Result::Failure[FailureType, SuccessType].new(error)
262
+ end
263
+ end
264
+
265
+ sig(:final) { returns(SuccessType) }
266
+ def success
267
+ @success_value
268
+ end
269
+
270
+ sig(:final) { override.returns(T::Boolean) }
271
+ def success?
272
+ true
273
+ end
274
+
275
+ sig(:final) { override.returns(T::Boolean) }
276
+ def failure?
277
+ false
278
+ end
279
+
280
+ sig(:final) { override.params(value: SuccessType).returns(SuccessType) }
281
+ def success_or(value)
282
+ @success_value
283
+ end
284
+
285
+ sig(:final) { override.params(value: FailureType).returns(FailureType) }
286
+ def failure_or(value)
287
+ value
288
+ end
289
+
290
+ sig(:final) { override.returns(Result[SuccessType, FailureType]) }
291
+ def flip
292
+ Mayak::Monads::Result::Failure[SuccessType, FailureType].new(@success_value)
293
+ end
294
+
295
+ sig(:final) {
296
+ override
297
+ .params(blk: T.proc.params(arg0: FailureType).returns(StandardError))
298
+ .returns(Mayak::Monads::Try[SuccessType])
299
+ }
300
+ def to_try(&blk)
301
+ Mayak::Monads::Try::Success.new(@success_value)
302
+ end
303
+
304
+ sig(:final) { override.returns(Mayak::Monads::Maybe[SuccessType]) }
305
+ def to_maybe
306
+ Mayak::Monads::Maybe::Some.new(@success_value)
307
+ end
308
+
309
+ sig(:final) {
310
+ override
311
+ .type_parameters(:Result)
312
+ .params(
313
+ failure_branch: T.proc.params(arg0: FailureType).returns(T.type_parameter(:Result)),
314
+ success_branch: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:Result))
315
+ ).returns(
316
+ T.type_parameter(:Result)
317
+ )
318
+ }
319
+ def either(failure_branch, success_branch)
320
+ success_branch.call(@success_value)
321
+ end
322
+
323
+ sig(:final) {
324
+ override
325
+ .params(blk: T.proc.params(arg0: SuccessType).void)
326
+ .returns(Result[FailureType, SuccessType])
327
+ }
328
+ def tee(&blk)
329
+ blk.call(@success_value)
330
+ self
331
+ end
332
+
333
+ sig(:final) {
334
+ override
335
+ .type_parameters(:NewFailure)
336
+ .params(
337
+ blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewFailure))
338
+ ).returns(
339
+ Result[T.type_parameter(:NewFailure), SuccessType]
340
+ )
341
+ }
342
+ def map_failure(&blk)
343
+ T.cast(
344
+ self,
345
+ Mayak::Monads::Result[T.type_parameter(:NewFailure), SuccessType]
346
+ )
347
+ end
348
+
349
+ sig(:final) {
350
+ override
351
+ .type_parameters(:NewFailure)
352
+ .params(
353
+ blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
354
+ ).returns(
355
+ Result[T.type_parameter(:NewFailure), SuccessType]
356
+ )
357
+ }
358
+ def flat_map_failure(&blk)
359
+ T.cast(
360
+ self,
361
+ Mayak::Monads::Result[T.type_parameter(:NewFailure), SuccessType]
362
+ )
363
+ end
364
+
365
+ sig(:final) {
366
+ override
367
+ .params(value: SuccessType)
368
+ .returns(Result[FailureType, SuccessType])
369
+ }
370
+ def recover(value)
371
+ self
372
+ end
373
+
374
+ sig(:final) {
375
+ override
376
+ .params(blk: T.proc.params(arg0: FailureType).returns(SuccessType))
377
+ .returns(Result[FailureType, SuccessType])
378
+ }
379
+ def recover_with(&blk)
380
+ self
381
+ end
382
+
383
+ sig(:final) {
384
+ override
385
+ .type_parameters(:NewFailure)
386
+ .params(blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType]))
387
+ .returns(Result[T.type_parameter(:NewFailure), SuccessType])
388
+ }
389
+ def recover_with_result(&blk)
390
+ T.cast(
391
+ self,
392
+ Mayak::Monads::Result[T.type_parameter(:NewFailure), SuccessType]
393
+ )
394
+ end
395
+ end
396
+
397
+ class Failure
398
+ extend T::Sig
399
+ extend T::Generic
400
+ extend T::Helpers
401
+
402
+ final!
403
+
404
+ FailureType = type_member
405
+ SuccessType = type_member
406
+
407
+ include Mayak::Monads::Result
408
+
409
+ sig(:final) { params(value: FailureType).void }
410
+ def initialize(value)
411
+ @failure_value = T.let(value, FailureType)
412
+ end
413
+
414
+ sig(:final) {
415
+ override
416
+ .type_parameters(:NewSuccess)
417
+ .params(blk: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:NewSuccess)))
418
+ .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
419
+ }
420
+ def map(&blk)
421
+ T.cast(
422
+ self,
423
+ Mayak::Monads::Result[FailureType, T.type_parameter(:NewSuccess)]
424
+ )
425
+ end
426
+
427
+ sig(:final) {
428
+ override
429
+ .type_parameters(:NewSuccess)
430
+ .params(
431
+ blk: T.proc.params(arg0: SuccessType).returns(Result[FailureType, T.type_parameter(:NewSuccess)])
432
+ )
433
+ .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
434
+ }
435
+ def flat_map(&blk)
436
+ T.cast(
437
+ self,
438
+ Mayak::Monads::Result[FailureType, T.type_parameter(:NewSuccess)]
439
+ )
440
+ end
441
+
442
+ sig(:final) {
443
+ override
444
+ .params(error: FailureType, blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
445
+ .returns(Result[FailureType, SuccessType])
446
+ }
447
+ def filter_or(error, &blk)
448
+ self
449
+ end
450
+
451
+ sig(:final) { returns(FailureType) }
452
+ def failure
453
+ @failure_value
454
+ end
455
+
456
+ sig(:final) { override.returns(T::Boolean) }
457
+ def success?
458
+ false
459
+ end
460
+
461
+ sig(:final) { override.returns(T::Boolean) }
462
+ def failure?
463
+ true
464
+ end
465
+
466
+ sig(:final) { override.params(value: SuccessType).returns(SuccessType) }
467
+ def success_or(value)
468
+ value
469
+ end
470
+
471
+ sig(:final) { override.params(value: FailureType).returns(FailureType) }
472
+ def failure_or(value)
473
+ @failure_value
474
+ end
475
+
476
+ sig(:final) { override.returns(Result[SuccessType, FailureType]) }
477
+ def flip
478
+ Mayak::Monads::Result::Success[SuccessType, FailureType].new(@failure_value)
479
+ end
480
+
481
+ sig(:final) {
482
+ override
483
+ .params(blk: T.proc.params(arg0: FailureType).returns(StandardError))
484
+ .returns(Mayak::Monads::Try[SuccessType])
485
+ }
486
+ def to_try(&blk)
487
+ Mayak::Monads::Try::Failure.new(blk.call(@failure_value))
488
+ end
489
+
490
+ sig(:final) { override.returns(Mayak::Monads::Maybe[SuccessType]) }
491
+ def to_maybe
492
+ Mayak::Monads::Maybe::None.new
493
+ end
494
+
495
+ sig(:final) {
496
+ override
497
+ .type_parameters(:Result)
498
+ .params(
499
+ failure_branch: T.proc.params(arg0: FailureType).returns(T.type_parameter(:Result)),
500
+ success_branch: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:Result))
501
+ ).returns(
502
+ T.type_parameter(:Result)
503
+ )
504
+ }
505
+ def either(failure_branch, success_branch)
506
+ failure_branch.call(@failure_value)
507
+ end
508
+
509
+ sig(:final) {
510
+ override
511
+ .params(blk: T.proc.params(arg0: SuccessType).void)
512
+ .returns(Result[FailureType, SuccessType])
513
+ }
514
+ def tee(&blk)
515
+ self
516
+ end
517
+
518
+ sig(:final) {
519
+ override
520
+ .type_parameters(:NewFailure)
521
+ .params(
522
+ blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewFailure))
523
+ ).returns(
524
+ Result[T.type_parameter(:NewFailure), SuccessType]
525
+ )
526
+ }
527
+ def map_failure(&blk)
528
+ Mayak::Monads::Result::Failure[T.type_parameter(:NewFailure), SuccessType].new(blk.call(@failure_value))
529
+ end
530
+
531
+ sig(:final) {
532
+ override
533
+ .type_parameters(:NewFailure)
534
+ .params(
535
+ blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
536
+ ).returns(
537
+ Result[T.type_parameter(:NewFailure), SuccessType]
538
+ )
539
+ }
540
+ def flat_map_failure(&blk)
541
+ blk.call(@failure_value)
542
+ end
543
+
544
+ sig(:final) {
545
+ override
546
+ .params(value: SuccessType)
547
+ .returns(Result[FailureType, SuccessType])
548
+ }
549
+ def recover(value)
550
+ Mayak::Monads::Result::Success[FailureType, SuccessType].new(value)
551
+ end
552
+
553
+ sig(:final) {
554
+ override
555
+ .params(blk: T.proc.params(arg0: FailureType).returns(SuccessType))
556
+ .returns(Result[FailureType, SuccessType])
557
+ }
558
+ def recover_with(&blk)
559
+ Mayak::Monads::Result::Success[FailureType, SuccessType].new(blk.call(@failure_value))
560
+ end
561
+
562
+ sig(:final) {
563
+ override
564
+ .type_parameters(:NewFailure)
565
+ .params(blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType]))
566
+ .returns(Result[T.type_parameter(:NewFailure), SuccessType])
567
+ }
568
+ def recover_with_result(&blk)
569
+ blk.call(@failure_value)
570
+ end
571
+ end
572
+ end
573
+ end
574
+ end