try/try.go at main · go-libfp/try · GitHub

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

package try

type Try[T any] struct {
	val T
	err error
}


func Ok[T any](t T) Try[T] {
	return Try[T]{t, nil}
}


func Err[T any](e error) Try[T] {
	var v T
	return Try[T]{v, e}
}


func Map[T any, U any](t Try[T], f func(x T) U) Try[U] {
	if t.err == nil {

		out := f(t.val)
		return Ok(out)
	}

	return Err[U](t.err)
}

func Bind[T, U any](t Try[T], f func(x T) Try[U]) Try[U] {
	if t.err == nil {
		return f(t.val)
	}

	return Err[U](t.err)

}

func WrapErr[T any](t T, err error) Try[T] {
	return Try[T]{t, err}
}

// Like bind but takes function that returns err tuples instead
func BindET[T, U any](t Try[T], f func(x T) (U, error) ) Try[U] {

	if t.err == nil {
		out := WrapErr( f(t.val) )
		return out
	}


        return Err[U](t.err)

}


func RetryN[T any](f func() Try[T], budget int) Try[T] {

	var out Try[T]

	for i := 0; i < budget; i++ {
		t := f()
		if t.IsOk() { return t}
		out = t
	}

	return out
}


func (t *Try[T]) Get() (T, error) {
	return t.val, t.err
}


func (t *Try[T]) OnErr(f func(e error)) {
	if t.err != nil {
		f(t.err)
	}
}


func (t *Try[T]) GetErr() error {
	return t.err
}

func (t *Try[T]) GetValue() T {
	return t.val
}


func (t *Try[T]) OnSuccess(f func(x T) ) {
	if t.err == nil {
		f(t.val)
	}
}


func (t *Try[T]) IsErr() bool {
	return t.err != nil
}

func (t *Try[T]) IsOk() bool {
	return t.err == nil
}