package tablecloth-base

  1. Overview
  2. Docs

Source file TableclothResult.ml

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
type ('ok, 'error) t = ('ok, 'error) result

let ok value = Ok value

let error value = Error value

let from_option ma ~error =
  match ma with None -> Error error | Some right -> Result.Ok right


let is_ok = Result.is_ok

let is_error = Result.is_error

let both a b =
  match (a, b) with
  | Ok a', Ok b' ->
      Ok (a', b')
  | Error a', _ ->
      Error a'
  | _, Error b' ->
      Error b'


let flatten = Result.join

let or_ a b = match a with Ok _ -> a | _ -> b

let or_else a b = match b with Ok _ -> b | _ -> a

let and_ a b = match a with Ok _ -> b | _ -> a

let unwrap = Result.value

let unwrap_lazy t ~default =
  match t with Ok t' -> t' | Error _ -> Lazy.force default


let unwrap_unsafe = Result.get_ok

let unwrap_error t ~default =
  match t with Ok _ -> default | Error error -> error


let map t ~f = Result.map f t

let map2 a b ~f =
  match (a, b) with
  | Ok a, Ok b ->
      Ok (f a b)
  | Error a, _ ->
      Error a
  | _, Error b ->
      Error b


let map_error t ~f =
  match t with Error error -> Error (f error) | Ok value -> Ok value


let values t =
  Base.List.fold_right t ~f:(map2 ~f:(fun a b -> a :: b)) ~init:(Ok [])


let combine (l : ('ok, 'error) result list) : ('ok list, 'error) result =
  (TableclothList.fold_right
     ~f:(fun (accum : ('ok list, 'error) result) (value : ('ok, 'error) result)
             : ('ok list, 'error) result ->
       map2 ~f:(fun (head : 'ok) (list : 'ok list) -> head :: list) value accum
       )
     ~initial:(Ok []) )
    l


let to_option r = match r with Ok v -> Some v | Error _ -> None

let and_then t ~f = Result.bind t f

let attempt f =
  match f () with value -> Ok value | exception error -> Error error


let tap t ~f = match t with Ok a -> f a | _ -> ()

let equal equal_ok equal_error a b =
  match (a, b) with
  | Error a', Error b' ->
      equal_error a' b'
  | Ok a', Ok b' ->
      equal_ok a' b'
  | _ ->
      false


let compare
    ~f:(compare_ok : 'ok -> 'ok -> int)
    ~g:(compare_error : 'error -> 'error -> int)
    (a : ('ok, 'error) t)
    (b : ('ok, 'error) t) : int =
  match (a, b) with
  | Error a', Error b' ->
      compare_error a' b'
  | Ok a', Ok b' ->
      compare_ok a' b'
  | Error _, Ok _ ->
      -1
  | Ok _, Error _ ->
      1


let ( |? ) t default = unwrap t ~default

let ( >>| ) t f = map t ~f

let ( >>= ) t f = and_then t ~f