This module provides option and result types that optionally contain a value; hence the name valor, short for "value or".
This is not an attempt to make Go code look less like Go. Instead, the goal is to codify the "comma ok" and "errors are values" principles that Go already encourages.
go get github.com/phelmkamp/valoroptional.Value is modeled after the "comma ok" idiom.
It contains a value (ok) or nothing (not ok).
m := map[string]int{"foo": 42}
val := optional.OfIndex(m, "foo")
fmt.Println(val.IsOk()) // true
var foo int
fmt.Println(val.Ok(&foo), foo) // true 42
valStr := optional.Map(val, strconv.Itoa)
fmt.Println(valStr) // {42 true}
val = optional.OfIndex(m, "bar")
fmt.Println(val.Or(-1)) // -1
fmt.Println(val.OrZero()) // 0
fmt.Println(val.OrElse(func() int { return 1 })) // 1result.Result contains either a value or an error.
// traditional
if res := result.Of(w.Write([]byte("foo"))); res.IsError() {
fmt.Println(res.Error())
return
}
// try to get value, printing wrapped error if not ok
// note: only relevant values are in-scope after handling
var n int
if res := result.Of(w.Write([]byte("foo"))); !res.Value().Ok(&n) {
fmt.Println(res.Errorf("Write() failed: %w").Error())
return
}
// same as above with multiple values
var s string
var b bool
if res := two.TupleResultOf(multi(false)); !res.Value().Do(
func(t two.Tuple[string, bool]) { s, b = t.Values() },
).IsOk() {
fmt.Println(res.Errorf("multi() failed: %w").Error())
return
}
// errors.Is
if res := result.Of(w.Write([]byte("foo"))); res.ErrorIs(io.ErrShortWrite) {
fmt.Println(res.Error())
return
}
// errors.As
if res := result.Of(w.Write([]byte("foo"))); res.IsError() {
var err *fs.PathError
if res.ErrorAs(&err) {
fmt.Println("path=" + err.Path)
}
fmt.Println(res.Error())
return
}
// errors.Unwrap
if res := result.Of(mid(true)); res.IsError() {
fmt.Println(res.ErrorUnwrap().Error())
return
}unit.Type, singleton.Set,
two.Tuple, three.Tuple, and
four.Tuple contain zero through four values respectively.
Among other things, they enable Value and Result to contain a variable number of values.
{% raw %}
get := func(string, int, bool) {
return "a", 1, true
}
val := two.TupleValueOf(get())
fmt.Println(val) // {{a 1} true}{% endraw %}
enum.Enum is an enumerated type.
It's initialized with a set of allowed values and then each "copy" optionally contains a currently selected value.
const (
Clubs = "clubs"
Diamonds = "diamonds"
Hearts = "hearts"
Spades = "spades"
)
var Suit = enum.OfString(Clubs, Diamonds, Hearts, Spades)
func main() {
fmt.Println(Suit.Values()) // [clubs diamonds hearts spades]
fmt.Println(Suit.ValueOf("Foo")) // { false}
fmt.Println(Suit.ValueOf(Hearts)) // {hearts true}
}Value is like Rust's Option.
Result is like Rust's Result.
A switch statement provides similar semantics to Rust's match:
var foo int
switch val {
case val.OfOk():
foo = val.MustOk()
fmt.Println("Ok", foo)
case optional.OfNotOk[int]():
fmt.Println("Not Ok")
return
}
var n int
switch res {
case res.OfOk():
n = res.Value().MustOk()
fmt.Println("Ok", n)
case res.OfError():
fmt.Println("Error", res.Error())
return
}Value is like Java's Optional.
This module is currently at v0 but every effort will be made to avoid breaking changes. Instead, functionality will be deprecated as needed with plans to remove in v1.
valorcheck is a linter to check that access to an optional value is guarded against the case where the value is not present.