List of Error [text.Baldanders.info]

goark/errs パッケージ v1.3.2 をリリースした

2023-06-26T12:22:20+00:00

この前書いた記事で，最後の方に「そうそう errors.Join 互換の関数ってあったほうがいいのかなぁ」と漠然と書いたのだが，その後，複数の goroutine を跨いでエラーハンドリングを行う必要ができたので， concurrency-safe なマルチエラー型 errs.Errors を作ってリリースした。

Release v1.3.2 · goark/errs · GitHub

いやぁ，並行処理書くの久しぶりで，色々とバグを潰してたら v1.3.2 まで上がってしまった（笑）

たとえば，こんな感じに使える。

package main

import (
    "fmt"
    "sync"

    "github.com/goark/errs"
)

func generateMultiError() error {
    errlist := &errs.Errors{}
    var wg sync.WaitGroup
    for i := 1; i <= 2; i++ {
        i := i
        wg.Add(1)
        go func() {
            defer wg.Done()
            errlist.Add(fmt.Errorf("error %d", i))
        }()
    }
    wg.Wait()
    return errlist.ErrorOrNil()
}

func main() {
    err := generateMultiError()
    fmt.Printf("%+v\n", err) // {"Type":"*errs.Errors","Errs":[{"Type":"*errors.errorString","Msg":"error 2"},{"Type":"*errors.errorString","Msg":"error 1"}]}
}

また errors.Join() 互換の関数も用意してみた。こんな感じ。

package main

import (
    "errors"
    "fmt"
    "io"
    "os"

    "github.com/goark/errs"
)

func generateMultiError() error {
    return errs.Join(os.ErrInvalid, io.EOF)
}

func main() {
    err := generateMultiError()
    fmt.Printf("%+v\n", err)            // {"Type":"*errs.Errors","Errs":[{"Type":"*errors.errorString","Msg":"invalid argument"},{"Type":"*errors.errorString","Msg":"EOF"}]}
    fmt.Println(errors.Is(err, io.EOF)) // true
}

今回新たに作った errs.Errors 型は Unwrap() []error メソッドを持っているため， Go 1.20 以降であれば errors.Is() および errors.As() 関数を使って評価することができる。

これで errors 標準パッケージと互換性ありと言えるようになったかな？

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

拙作 gorak/errs パッケージの性能評価をしてもらった

2023-06-24T01:06:56+00:00

こんなマイナーなパッケージの性能評価をしていただいてありがとうございます 🙇 いや，マジで。

pkg/errors は昔から人気の高いエラーハンドリング・パッケージで，私も随分お世話になった。このパッケージの更新が止まって read-only になったのに伴い代替となるパッケージが望まれていたのは知っている。で，登場したのが cockroachdb/errors パッケージなわけだ。

cockroachdb/errors パッケージは，おそらく CockroachDB などのデータベース操作に向いたエラーハンドリング・パッケージと思われ， pkg/errors との互換性を維持したまま PII (Personally Identifiable Information) のマスキングもできる優れものである。 pkg/errors からの乗り換えを考えるなら cockroachdb/errors パッケージはアリな選択だと思うし個人的にもお勧めである。

一方で拙作の goark/errs はもう少し違うところを目指していて

任意の error インスタンスをラッピングすることに主眼を置く
- 任意の error インスタンスを原因エラーとして埋め込み可能
任意のコンテキスト情報を埋め込み可能
- 既定でエラーが発生した関数名をコンテキスト情報として保持する
構造化されたエラー情報を JSON 形式で出力可能
- MarshalJSON() メソッド完備
- 書式 %+v を使って JSON 形式で出力
- 任意の error インスタンスで（Unwrap メソッドの挙動に従い）可能な限り構造を辿って出力

といった機能を有している。もちろんこれは pkg/errors パッケージに対するささやかな不満から来ている。

私は「スタック情報は9割以上がノイズ」「藁束の中から金の針を探すようなもの」という危険思想の持ち主なので，どういう形であれスタック情報を丸ごとどーんと出力することはしないようにしている。他人様が書いた Java コードのデバッグでカジュアルにスタックトレースを吐き出しやがる（しかもそれを見ても結局分からずデバッガを動かす羽目になる）のに辟易してたというのもある。

それならスタック情報はエラーを吐き出した関数名を保持するのみとし，あとはエラーに至る「文脈（context）」をできる限りかき集めてエラー・インスタンスに突っ込むという戦略のほうが幾らかマシだろう，と考えたのだ。どうしても関数呼び出しの構造が欲しければ，エラーを検出した時点で都度ラッピングしていけばいいという考え方である。

ところで最初に挙げた記事では

出力の処理は json.Marshal と fmt.Sprintf を使っています。 json.Marshal を高速化するために goccy/go-json に変えるのもありかもしれません。

次なる pkg/errors を探してを読んでより

と評価をいただいていて， JSON の marshalling については（一瞬心が揺らいだが）性能がよくてもサードパーティのパッケージには依存したくないというのがあるので，パスさせていただくが， fmt.Sprintf に関しては正直に言って実装をサボっているだけなので，少し改善してみることにした。

まずは miyataka/benchmark_pkg_errors_alternatives を拝借して改めてベンチマークをとってみる。他のパッケージと比べても仕方がないので goark/errs を使った結果のみ示すと

benchmark	ns/op	B/op	allocs/op
BenchmarkErrors/goark/errs-stack-10-12	2746	648	7
BenchmarkErrors/goark/errs-stack-100-12	3278	648	7
BenchmarkErrors/goark/errs-stack-1000-12	6810	648	7
BenchmarkStackFormatting/goark/errs-%s-stack-10-12	167.3	8	1
BenchmarkStackFormatting/goark/errs-%v-stack-10-12	185.0	8	1
BenchmarkStackFormatting/goark/errs-%+v-stack-10-12	8680	1401	33
BenchmarkStackFormatting/goark/errs-%s-stack-30-12	174.8	8	1
BenchmarkStackFormatting/goark/errs-%v-stack-30-12	180.4	8	1
BenchmarkStackFormatting/goark/errs-%+v-stack-30-12	8826	1401	33
BenchmarkStackFormatting/goark/errs-%s-stack-60-12	170.0	8	1
BenchmarkStackFormatting/goark/errs-%v-stack-60-12	160.5	8	1
BenchmarkStackFormatting/goark/errs-%+v-stack-60-12	8636	1401	33

うっ，アロケート回数が33回とか orz

凹みつつも JSON データ生成部分でなるべく fmt.Sprintf を使わないようにした v1.2.3 をリリースした。

Release v1.2.3 · goark/errs · GitHub

これを使って同じ条件でベンチマークをとってみたのだが

benchmark	ns/op	B/op	allocs/op
BenchmarkErrors/goark/errs-stack-10-12	2850	648	7
BenchmarkErrors/goark/errs-stack-100-12	3344	648	7
BenchmarkErrors/goark/errs-stack-1000-12	6365	648	7
BenchmarkStackFormatting/goark/errs-%s-stack-10-12	167.7	8	1
BenchmarkStackFormatting/goark/errs-%v-stack-10-12	164.6	8	1
BenchmarkStackFormatting/goark/errs-%+v-stack-10-12	7098	1385	31
BenchmarkStackFormatting/goark/errs-%s-stack-30-12	171.8	8	1
BenchmarkStackFormatting/goark/errs-%v-stack-30-12	171.5	8	1
BenchmarkStackFormatting/goark/errs-%+v-stack-30-12	6974	1385	31
BenchmarkStackFormatting/goark/errs-%s-stack-60-12	173.9	8	1
BenchmarkStackFormatting/goark/errs-%v-stack-60-12	164.8	8	1
BenchmarkStackFormatting/goark/errs-%+v-stack-60-12	7097	1385	31

ちょっとしか変わらん orz やっぱ json.Marshal を使ってるのがあかんのか？そもそも改善になってない？

…というわけで諦めました。こんなのでよろしければ使ってやってください。

そうそう errors.Join 互換の関数ってあったほうがいいのかなぁ。それをするにはマルチエラー用の型を作らないといけないのだが… これはちょっと考えてみてもいいかも。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

初めてのGo言語 ―他言語プログラマーのためのイディオマティックGo実践ガイド: Jon Bodner (著), 武舎広幸 (翻訳); オライリージャパン 2022-09-26; 単行本（ソフトカバー）; 4814400047 (ASIN), 9784814400041 (EAN), 4814400047 (ISBN); 評価

2021年に出た “Learning Go” の邦訳版。私は版元で PDF 版を購入。 Go 特有の語法（idiom）を切り口として Go の機能やパッケージを解説している。 Go 1.19 対応。

reviewed by Spiegel on 2022-10-11 (powered by PA-APIv5)

デベロッパーゴースーパーゴラン Tシャツ: Geek Go Super Golang Tees; ウェア&シューズ; B09C2XBC2F (ASIN); 評価

ついカッとなってポチった。反省はしない

reviewed by Spiegel on 2022-04-10 (powered by PA-APIv5)

goark/errs パッケージ v1.2.1 をリリースした

2023-02-08T03:45:17+00:00

おそらく私しか使ってないであろう，エラーハンドリング用の /github.com/goark/errs パッケージ v1.2.1 をリリースした。

実は v1.2.0 でチョンボして v1.2.1 として出し直している。ごめんペコン。

Go 1.20 で Unwrap() []error メソッドを持つマルチエラーをサポートするようになったため，その対応。たとえば，複数の原因エラーがある場合に，標準の errors.Join() 関数などと組み合わせて

package main

import (
    "errors"
    "fmt"
    "io"
    "os"

    "github.com/goark/errs"
)

func generateMultiError() error {
    return errs.New("error with multiple causes", errs.WithCause(errors.Join(os.ErrInvalid, io.EOF)))
}

func main() {
    err := generateMultiError()
    fmt.Println(errors.Is(err, io.EOF)) // true
}

てな感じに書くことができる。ちなみに

func main() {
    err := generateMultiError()
    fmt.Printf("%+v\n",  err)
}

と書き換えて実行すると

$ go run sample4.go | jq .
{
  "Type": "*errs.Error",
  "Err": {
    "Type": "*errors.errorString",
    "Msg": "error with multiple causes"
  },
  "Context": {
    "function": "main.generateMultiError"
  },
  "Cause": {
    "Type": "*errors.joinError",
    "Msg": "invalid argument\nEOF",
    "Cause": [
      {
        "Type": "*errors.errorString",
        "Msg": "invalid argument"
      },
      {
        "Type": "*errors.errorString",
        "Msg": "EOF"
      }
    ]
  }
}

マルチエラー部分もいい感じに JSON 出力できる。

以前の errs.Cause() 関数には Deprecated マークを付けた（マルチエラーに対応できないため）。

// Deprecated: should not be used
func Cause(err error) error {
    for err != nil {
        unwraped := errors.Unwrap(err)
        if unwraped == nil {
            return err
        }
        err = unwraped
    }
    return err
}

Deprecated マークを付けた型や関数を使用すると lint などで注意喚起してくれる。便利。

errs.Cause() 関数の代わりと言ってはナニだが errs.Unwraps() 関数を用意した。

func Unwraps(err error) []error {
    if err != nil {
        if es, ok := err.(interface {
            Unwrap() []error
        }); ok {
            return es.Unwrap()
        }
    }
    e := errors.Unwrap(err)
    if e != nil {
        return []error{e}
    }
    return nil
}

この関数を使えば原因エラーを []error で返してくれる（原因エラーが単一の場合もスライスで返すので注意）。

マルチエラーを格納する独自の型を作ることも一瞬考えたが，標準の errors.Join() 関数などで作れば必要十分だと思うし，足りなければ改めて考えるか。ということで今回はここまで。

ブックマーク

【Go 1.20 の予習】複数 error を返す Unwrap メソッドについて
Go 言語用エラーハンドリング・パッケージ
Go のエラーハンドリング : Zenn 本書きました

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

初めてのGo言語 ―他言語プログラマーのためのイディオマティックGo実践ガイド: Jon Bodner (著), 武舎広幸 (翻訳); オライリージャパン 2022-09-26; 単行本（ソフトカバー）; 4814400047 (ASIN), 9784814400041 (EAN), 4814400047 (ISBN); 評価

reviewed by Spiegel on 2022-10-11 (powered by PA-APIv5)

実用 Go言語 ―システム開発の現場で知っておきたいアドバイス: 渋川よしき (著), 辻大志郎 (著), 真野隼記 (著); オライリージャパン 2022-04-22; 単行本（ソフトカバー）; 4873119693 (ASIN), 9784873119694 (EAN), 4873119693 (ISBN); 評価

版元のデジタル版を購入。 Go で躓きやすい点を解説していくのが最初の動機らしい。「◯◯するには」を調べる際にこの本を調べるといいかも。

reviewed by Spiegel on 2022-10-26 (powered by PA-APIv5)

【Go 1.20 の予習】複数 error を返す Unwrap メソッドについて

2023-01-25T03:57:01+00:00

おそらく 2022-02 にリリースされる Go 1.20 で errors パッケージの仕様が変わるみたいなので予習しておく。

Wrapping multiple errors

Go 1.20 expands support for error wrapping to permit an error to wrap multiple other errors.

An error e can wrap more than one error by providing an Unwrap method that returns a []error.

The errors.Is and errors.As functions have been updated to inspect multiply wrapped errors.

The fmt.Errorf function now supports multiple occurrences of the %w format verb, which will cause it to return an error that wraps all of those error operands.

The new function errors.Join returns an error wrapping a list of errors.

via Go 1.20 Release Notes - The Go Programming Language

現行の errors.Is() および errors.As() 各関数では対象となる error インスタンスについて型アサーションを行い Unwrap() error メソッドを含む型か否かで再帰的に処理を行っているが， Go 1.20 からは，この評価に Unwrap() []error メソッドが加わる。

具体的にはこんな感じらしい。

// Is reports whether any error in err's tree matches target.
//
// The tree consists of err itself, followed by the errors obtained by repeatedly
// calling Unwrap. When err wraps multiple errors, Is examines err followed by a
// depth-first traversal of its children.
//
// An error is considered to match a target if it is equal to that target or if
// it implements a method Is(error) bool such that Is(target) returns true.
//
// An error type might provide an Is method so it can be treated as equivalent
// to an existing error. For example, if MyError defines
//
//    func (m MyError) Is(target error) bool { return target == fs.ErrExist }
//
// then Is(MyError{}, fs.ErrExist) returns true. See syscall.Errno.Is for
// an example in the standard library. An Is method should only shallowly
// compare err and the target and not call Unwrap on either.
func Is(err, target error) bool {
    if target == nil {
        return err == target
    }

    isComparable := reflectlite.TypeOf(target).Comparable()
    for {
        if isComparable && err == target {
            return true
        }
        if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
            return true
        }
        switch x := err.(type) {
        case interface{ Unwrap() error }:
            err = x.Unwrap()
            if err == nil {
                return false
            }
        case interface{ Unwrap() []error }:
            for _, err := range x.Unwrap() {
                if Is(err, target) {
                    return true
                }
            }
            return false
        default:
            return false
        }
    }
}

// As finds the first error in err's tree that matches target, and if one is found, sets
// target to that error value and returns true. Otherwise, it returns false.
//
// The tree consists of err itself, followed by the errors obtained by repeatedly
// calling Unwrap. When err wraps multiple errors, As examines err followed by a
// depth-first traversal of its children.
//
// An error matches target if the error's concrete value is assignable to the value
// pointed to by target, or if the error has a method As(interface{}) bool such that
// As(target) returns true. In the latter case, the As method is responsible for
// setting target.
//
// An error type might provide an As method so it can be treated as if it were a
// different error type.
//
// As panics if target is not a non-nil pointer to either a type that implements
// error, or to any interface type.
func As(err error, target any) bool {
    if err == nil {
        return false
    }
    if target == nil {
        panic("errors: target cannot be nil")
    }
    val := reflectlite.ValueOf(target)
    typ := val.Type()
    if typ.Kind() != reflectlite.Ptr || val.IsNil() {
        panic("errors: target must be a non-nil pointer")
    }
    targetType := typ.Elem()
    if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
        panic("errors: *target must be interface or implement error")
    }
    for {
        if reflectlite.TypeOf(err).AssignableTo(targetType) {
            val.Elem().Set(reflectlite.ValueOf(err))
            return true
        }
        if x, ok := err.(interface{ As(any) bool }); ok && x.As(target) {
            return true
        }
        switch x := err.(type) {
        case interface{ Unwrap() error }:
            err = x.Unwrap()
            if err == nil {
                return false
            }
        case interface{ Unwrap() []error }:
            for _, err := range x.Unwrap() {
                if As(err, target) {
                    return true
                }
            }
            return false
        default:
            return false
        }
    }
}

ちょっと長くて申し訳ないが，各関数の型 switch 文のなかで Unwrap() []error メソッドを含む型を評価しているのがおわかりだろうか。

標準パッケージでは新設の errors.Join() 関数や fmt.Errorf() 関数の拡張でマルチエラーに対応するようだが，自前で error 型を作る場合でも Unwrap() []error メソッドを追加することで errors.Is() 関数や errors.As() 関数による評価が可能になるわけだ。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

初めてのGo言語 ―他言語プログラマーのためのイディオマティックGo実践ガイド: Jon Bodner (著), 武舎広幸 (翻訳); オライリージャパン 2022-09-26; 単行本（ソフトカバー）; 4814400047 (ASIN), 9784814400041 (EAN), 4814400047 (ISBN); 評価

reviewed by Spiegel on 2022-10-11 (powered by PA-APIv5)

実用 Go言語 ―システム開発の現場で知っておきたいアドバイス: 渋川よしき (著), 辻大志郎 (著), 真野隼記 (著); オライリージャパン 2022-04-22; 単行本（ソフトカバー）; 4873119693 (ASIN), 9784873119694 (EAN), 4873119693 (ISBN); 評価

版元のデジタル版を購入。 Go で躓きやすい点を解説していくのが最初の動機らしい。「◯◯するには」を調べる際にこの本を調べるといいかも。

reviewed by Spiegel on 2022-10-26 (powered by PA-APIv5)

spiegel-im-spiegel/errs パッケージ v1.0.4 をリリースした

2021-07-15T11:42:27+00:00

Zenn で pkg/errors の不具合（？）について教えてもらった。

Unwrap doesn’t return the base error · Issue #223 · pkg/errors · GitHub

これを見たときは完全に他人事だったのだが，よく考えたら拙作の spiegel-im-spiegel/errs では pkg/errors の設計コンセプトを参考にしているのでもしかして… と思って調べたら別のところで不具合を見つけてしまった orz

具体的には errs.New() 関数で生成したインスタンスに標準の errors.Unwrap() をかけても返り値が nil にならないというもの。ちうわけで，修正版をリリースした。

Release v1.0.4 · spiegel-im-spiegel/errs · GitHub

言い訳するなら，実際のエラーハンドリングで errors.Unwrap() を使って手動でひとつずつ階層を遡るとかしないよね，普通。いや，マジすんません 🙇

エラーハンドリングについて，最近読んで面白いと思ったのが以下の記事。

Goエラーハンドリング戦略

特にクラウド環境下でロギングと絡めたハンドリングは参考になるだろう。

この記事の中で「サードパーティのロガーやエラーハンドラは極力使わない」というのは半分くらいは同意。でも，サードパーティの汎用パッケージじゃなくても，結局は対象となるツール・サービスの設計に合わせて「自分で作ったほうが早い」ってのはあるんだよなぁ。だから私も自前で作ってるんだけど（笑）

ブックマーク

Go 言語用エラーハンドリング・パッケージ
Go のエラーハンドリング : Zenn 本書きました

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Go 製のツールとパッケージをまとめてアップデートした

2020-10-02T07:40:54+00:00

GitHub リポジトリにある Go 言語製のツールやパッケージについて GitHub Actions で CI (Continuous Integration) を回す目処が立ったので，設定を変更しリリースし直すことにした。今回リリースしたツール・パッケージのうち主なものは以下の通り。

若干 lint に叱られたり軽微なバグを指摘されたりしたものもあるが，機能上の追加・変更はない。

それじゃあ，次のステージに行きましょう♪

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

射手座☆午後九時Don't be late: シェリル・ノーム starring May'n (メインアーティスト); FlyingDog 2008-05-08 (Release 2017-01-16); MP3 ダウンロード; B01MZ8UA8O (ASIN); 評価

移動中に聴くとノリノリになれる（笑）

reviewed by Spiegel on 2020-10-02 (powered by PA-APIv5)

エラーハンドリング・パッケージ errs v1.0.0 他のリリース【Go 1.15 リリース記念】

2020-08-13T00:48:44+00:00

この前 v0.7.0 を出したばかりだが，予告したとおり， Go 1.15 リリースを記念して spiegel-im-spiegel/errs パッケージのメジャー・バージョンを上げることにした。

Release v1.0.0 · spiegel-im-spiegel/errs · GitHub

機能追加なし。不具合修正もなし。 go.mod と Travis CI の設定を変更して Go 1.15 に対応させただけの簡単なお仕事デス。

今後は後方互換性をきちんと考えて改修していく予定です m(_ _)m

ついでに spiegel-im-spiegel/errs パッケージを利用している主なパッケージやツールもバージョンを上げた。

基本的には spiegel-im-spiegel/errs パッケージのバージョンを上げただけ。まぁ v0.7.0 で後方互換性をぶっ壊しているので，手直しが多かったけど（笑）

32ビット・バイナリの提供を止めました

gpgpdump, books-data, gnkf, mklink の各ツールはバイナリでの提供も行っているが，今回から32ビット・バイナリの提供を止めることにした（ARM アーキテクチャを除く）。

きっかけは Go 1.15 で darwin/386 のサポートが終了したこと。

As announced in the Go 1.14 release notes, Go 1.15 drops support for 32-bit binaries on macOS, iOS, iPadOS, watchOS, and tvOS (the darwin/386 and darwin/arm ports). Go continues to support the 64-bit darwin/amd64 and darwin/arm64 ports.

via Go 1.15 Release Notes - The Go Programming Language

クロスコンパイルは GoReleaser を使ってるのでそんなに面倒ではないんだけど… もう32ビット流行らんべ。 Windows で古い32ビット機を（しかも拙作を）使ってる人は多分いないだろうし Ubuntu も最新 LTS では遂に32ビット・アーキテクチャのサポートを終了したしね。

まぁ Pure Go で書いてるのでダウンロード&ビルドは難しくないし，たいした問題ではないだろう，うんうん。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Go 言語用エラーハンドリング・パッケージ errs v0.7.0 をリリースした

2020-08-08T01:03:25+00:00

Go 言語用エラーハンドリング・パッケージ errs の v0.7.0 をリリースした。

Release v0.7.0 · spiegel-im-spiegel/errs · GitHub

「後方互換性？なにそれおいしいの？」って感じでド派手に書き換えている。使い方は以下を参照のこと。

Go 言語用エラーハンドリング・パッケージ

改めて紹介すると， spiegel-im-spiegel/errs は以下の設計コンセプトで作成・公開した Go 言語用エラーハンドリング・パッケージである。

Go 1.13 以降の標準パッケージ errors と置き換え可能
任意の error インスタンスをラッピング可能
任意の error インスタンスを原因エラーとして埋め込み可能
任意のコンテキスト情報を埋め込み可能
- 既定でエラーが発生した関数名をコンテキスト情報として保持する
構造化されたエラー情報を JSON 形式で出力可能
- MarshalJSON() メソッド完備
- 書式 %+v を使って JSON 形式で出力
- 任意の error インスタンスで可能な限り構造を辿って出力

v0.7.0 で個人的に欲しい機能は全て搭載したので， Go 1.15 の正式リリースを待って，問題がなければこのまま v1.0 に格上げする予定である。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

エラー・ハンドリングのキホン

2020-04-06T12:11:43+00:00

今日の起点となるコードはこれにしよう。

fn parse_string(s: &str) -> Result<u32, std::num::ParseIntError> {
    s.parse::<u32>()
}

fn main() {
    println!("{:?}", parse_string("-1")); //Output: Err(ParseIntError { kind: InvalidDigit })
}

parse_string() 関数の返り値の型 Result は列挙型 enum で¹，以下の2つの列挙子（variant）で構成されている。

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Result など列挙型の評価には match 式を使う。たとえば parse() に失敗した際に 0 をセットしたいなら

fn main() {
    let n = match parse_string("-1") {
        Ok(x) => x,
        Err(_) => 0,
    };
    println!("{}", n); //Output: 0
}

などと書くことができる。

Result 型を使ったエラー・ハンドリング

このように Result 型を使うことで基本的なエラー・ハンドリングが可能になる。いくつか例を挙げていこう。

Panic を投げる

parse_string() 関数が Err を返した場合に強制終了したいのであれば

fn main() {
    let n = match parse_string("-1") {
        Ok(x) => x,
        Err(e) => panic!(e), //Output: thread 'main' panicked at 'Box<Any>', src/main.rs:8:19
    };
    println!("{}", n); //do not reach
}

と panic! マクロで panic を投げればよい。ちなみに，環境変数 RUST_BACKTRACE に 1 をセットすると panic 時にスタックトレース情報も吐く。

単に panic を投げればいいのであれば Result::unwrap() メソッドを使えば上述のコードとほぼ同じ結果が得られる。

fn main() {
    let n = parse_string("-1").unwrap(); //Output: thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }', src/main.rs:6:13
    println!("{}", n); //do not reach
}

Panic を投げる際のメッセージを指定するには Result::expect() メソッドを使う。

fn main() {
    let n = parse_string("-1").expect("error in parse_string() function"); //Output: thread 'main' panicked at 'error in parse_string() function: ParseIntError { kind: InvalidDigit }', src/main.rs:6:13
    println!("{}", n); //do not reach
}

Panic 以外のハンドリング

エラー時に単に panic を投げるのではなく，何らかの処理を行って普通にプロセスを終了したいのであれば Result::unwrap_or_else() メソッドを使って

fn main() {
    let n = parse_string("-1").unwrap_or_else(|e| {
        println!("Error in parse_string() function: {:?}", e); //Output: Error in parse_string() function: ParseIntError { kind: InvalidDigit }
        std::process::exit(1);
    });
    println!("{}", n); //do not reach
}

などとすることもできる。プロセスを終了するのではなく，最初の例のように解析失敗時に 0 をセットしたいなら

fn main() {
    let n = parse_string("-1").unwrap_or_else(|_| 0);
    println!("{}", n); //Output: 0
}

てな感じにも書ける。あるいはもっと簡単に Result::unwrap_or() メソッドを使って

fn main() {
    let n = parse_string("-1").unwrap_or(0);
    println!("{}", n); //Output: 0
}

とも書ける。

エラーの委譲

次に以下の関数を考える。 2つの数文字列を与えて組（tuple）にして返す。

fn parse_pair_strings(s1: &str, s2: &str) -> Result<(u32, u32), std::num::ParseIntError> {
    let x = match s1.parse::<u32>() {
        Ok(n) => n,
        Err(e) => return Err(e),
    };
    let y = match s2.parse::<u32>() {
        Ok(n) => n,
        Err(e) => return Err(e),
    };
    Ok((x, y))
}

fn main() {
    println!("{:?}", parse_pair_strings("1", "-1")); //Output: Err(ParseIntError { kind: InvalidDigit })
}

parse_pair_strings() の仮引数 s1 および s2 に対してそれぞれ parse() を行うのだが，返り値が Err の際にはエラーをそのまま返して呼び出し元にハンドリングを委譲している。

返り値の型が同じ Result なら ? 演算子を使ってエラーの委譲をもっと簡単に書くことができる。こんな感じ。

fn parse_pair_strings(s1: &str, s2: &str) -> Result<(u32, u32), std::num::ParseIntError> {
    Ok((s1.parse::<u32>()?, s2.parse::<u32>()?))
}

すっきりー！

エラーの汎化

今度は，引数に文字列を渡すのではなく，標準入力から文字列を取得して parse() してみよう。

fn parse_from_stdin() -> Result<u32, std::num::ParseIntError> {
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf)?; //Compile error: `?` couldn't convert the error to `std::num::ParseIntError`
    buf.trim().parse::<u32>()
}

当然ながらこれはコンパイルエラーになる。何故なら read_line() 関数では Err の値が std::io::Error 型になるので std::num::ParseIntError 型とはマッチしないためだ。

これを解決するには std::error::Error 型を汎化型として使えばよい。

std::error::Error 型を使う際は Box<dyn Trait> にするようだ。こんな感じ。

fn parse_from_stdin() -> Result<u32, Box<dyn std::error::Error>> {
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf)?;
    let n = buf.trim().parse::<u32>()?;
    Ok(n)
}

fn main() {
    println!("{:?}", parse_from_stdin());
}

実行するとこんな感じになる。

$ echo -1 | cargo run
Err(ParseIntError { kind: InvalidDigit })

main() 関数側でもう少し細かくエラーを見てみよう。こんな感じかなぁ。

fn main() {
    let n = match parse_from_stdin() {
        Ok(x) => x,
        Err(err) => {
            match err.downcast_ref::<std::io::Error>() {
                Some(e) => {
                    println!("io::Error in parse_from_stdin(): {}", e);
                    std::process::exit(1);
                }
                _ => (),
            };
            match err.downcast_ref::<std::num::ParseIntError>() {
                Some(e) => {
                    println!("ParseIntError in parse_from_stdin(): {}", e);
                    std::process::exit(1);
                }
                _ => (),
            };
            println!("Other error in parse_from_stdin(): {}", err);
            std::process::exit(1);
        }
    };
    println!("{}", n);
}

こうすれば Box<dyn std::error::Error> 型からもとのエラー型を抽出して個別に処理できそう。これを実行するとこんな感じ。

$ echo -1 | cargo run
ParseIntError in parse_from_stdin(): invalid digit found in string

んー。かなり面倒くさいな。もう少しマシな戦略を探すべきか。

Option 型を使ったエラー・ハンドリング

上述のコードにある downcast_ref() メソッドは Option 型の値を返す。 Option 型も列挙型で，以下の2つの列挙子で構成されている。

enum Option<T> {
    Some(T),
    None,
}

None はいわゆる Null 値，つまり値がないことを示す。関数の実行結果が Null 値を取り得る場合に Option 型を返すことで，呼び出し元に Null 値のハンドリングを促すことができる。

起点のコードはこんな感じでどうだろうか。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        println!("{}: {:?}", i, nihongo.chars().nth(i));
    }
}

実行するとこんな感じになる。

$ cargo run
0: Some('日')
1: Some('本')
2: Some('語')
3: None

Panic を投げる

結果が None なら panic を投げるようにしてみる。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        let ch = match nihongo.chars().nth(i) {
            Some(c) => c,
            None => panic!("Out of bounds"),
        };
        println!("{}: {}", i, ch)
    }
}

実行するとこんな感じ。

$ cargo run
0: 日
1: 本
2: 語
thread 'main' panicked at 'Out of bounds', src/main.rs:6:21

また Option 型にも unwrap() や expect() といったメソッドがあり， None が返ったら panic を投げる。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        println!("{}: {}", i, nihongo.chars().nth(i).expect("Out of bounds"));
    }
}

$ cargo run
0: 日
1: 本
2: 語
thread 'main' panicked at 'Out of bounds', src/main.rs:4:31

Panic 以外のハンドリング

たとえば，こんな感じかな。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        let ch = match nihongo.chars().nth(i) {
            Some(c) => c,
            None => break,
        };
        println!("{}: {}", i, ch)
    }
}

$ cargo run
0: 日
1: 本
2: 語

まぁイテレータやコレクションでこんな書き方する人はおらんじゃろうけど。あンまりいい例示じゃなくてすまん。

やっぱ例外処理は要らんよね

Rust の列挙型は（C/C++ や Java などと異なり）型の列挙を行い，パターン・マッチングによって処理を振り分ける。この仕組みを上手く使ってエラー・ハンドリングを行っているわけだ。

こうやってみると，やっぱ例外処理は要らんよね（笑）

ブックマーク

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

Eブック版あり。公式ドキュメントよりも系統的に書かれているので痒いところに手が届く感じ。ただし量が多いので，一度斜め読みしたらあとは傍らに置いて必要に応じてつまみ食いしていくのがいいだろう。

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

列挙型については「Rust の型に関する覚え書き」を参照のこと。 ↩︎

Go 1.13.6 がリリースされた，他

2020-01-13T04:14:28+00:00

遅まきながら（笑）

Go 1.13.6 がリリースされた。

Go 1.13.6 and Go 1.12.15 are released - Google Group

今回もセキュリティ・アップデートはなし。

go1.13.6 (released 2020/01/09) includes fixes to the runtime and the net/http package. See the Go 1.13.6 milestone on our issue tracker for details.

via Release History - The Go Programming Language

例によって Ubuntu の APT で管理している Go コンパイラは古いので，ダウンロードページからバイナリ（go1.13.6.linux-amd64.tar.gz）を取ってきて手動でインストールすることを強く推奨する。

$ cd /usr/local/src
$ sudo curl "https://dl.google.com/go/go1.13.6.linux-amd64.tar.gz" -O
$ cd ..
$ sudo unlink go # 以前の Go が入っている場合
$ sudo tar xvf src/go1.13.6.linux-amd64.tar.gz
$ sudo mv go go1.13.6
$ sudo ln -s go1.13.6 go
$ go version # /usr/local/go/bin にパスが通っている場合
go version go1.13.6 linux/amd64

アップデートは計画的に。

pkg/errors v0.9.0 がリリースされた

pkg/errors の v0.9.0 がリリースされたようだ。

errors 0.9.0 is a preparation release for a 1.0 final release. Also we were working on removing support for Go 1.8, 1.9 and 1.10 and earlier, and become compatible this package with new way of errors on Go 1.13.

via Release errors 0.9.0 · pkg/errors

おおっ！

中身を見ると，標準の errors.Is(), errors.As(), および errors.Unwrap() 各関数を置き換え可能になっていて，さらに pkg/errors の特徴である Cause() 関数も使えるようになっている。

func Cause(err error) error {
    type causer interface {
        Cause() error
    }

    for err != nil {
        if cause, ok := err.(causer); ok {
            err = cause.Cause()
        } else if unwrapped := Unwrap(err); unwrapped != nil {
            err = unwrapped
        } else {
            break
        }
    }
    return err
}

ふむむー。拙作の spiegel-im-spiegel/errs の Cause() 関数もこれに追従しておこうかな。いや pkg/errors の *.Cause() メソッドって *.Unwrap() メソッドと等価みたいだし，無理に合わせないほうがいいか。

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価