Golang通用可选值与结果类型处理插件库valor的使用

介绍

valor模块提供了可选值和结果类型，它们可能包含一个值（因此命名为"valor"，是"value or"的缩写）。这不是为了让Go代码看起来不像Go，而是为了将Go已经鼓励的"comma ok"和"errors are values"原则编码化。

安装

go get github.com/phelmkamp/valor

类型

Value

optional.Value模拟了"comma ok"的习惯用法。它包含一个值(ok)或什么都没有(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 })) // 1

Result

result.Result包含一个值或一个错误。

// 传统方式
if res := result.Of(w.Write([]byte("foo"))); res.IsError() {
    fmt.Println(res.Error())
    return
}

// 尝试获取值，如果不ok则打印包装的错误
// 注意：处理之后只有相关值在作用域内
var n int
if res := result.Of(w.Write([]byte("foo"))); !res.Value().Ok(&n) {
    fmt.Println(res.Errorf("Write() failed: %w").Error())
    return
}

// 与上面相同，但有多个值
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
}

Tuples

unit.Type, singleton.Set, two.Tuple, three.Tuple和four.Tuple分别包含零到四个值。它们使Value和Result能够包含可变数量的值。

get := func(string, int, bool) {
    return "a", 1, true
}
val := two.TupleValueOf(get())
fmt.Println(val) // {{a 1} true}

Enum

enum.Enum是一个枚举类型。它用一组允许的值初始化，然后每个"副本"可选地包含一个当前选择的值。

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}
}

其他语言中的类似概念

Rust

Value类似于Rust的Option。Result类似于Rust的Result。

switch语句提供了与Rust的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
}

Java

Value类似于Java的Optional。

发布

该模块目前处于v0版本，但将尽一切努力避免破坏性更改。相反，功能将根据需要被弃用，并计划在v1中删除。

Linter

valorcheck是一个linter，用于检查对可选值的访问是否针对值不存在的情况进行了保护。