List of Type [text.Baldanders.info]

特殊形式による式評価について

2021-03-04T10:27:13+00:00

元ネタが Zenn の記事だし小ネタだし，どちらで書こうか悩んだが，今まで書いたことがない切り口な気がするので，こっち側で。

いきなりだが，以下のコードを起点に話を始めよう。

package main

import "fmt"

func main() {
    ageMap := map[string]uint{
        "Alice": 18,
        "Teles": 20,
    }
    fmt.Println(ageMap["Alice"])
    // Output
    // 18
}

このコードをみて分かるように，インデックス式 ageMap[x] の評価結果は uint 型になっている（インデックス値が存在しない場合はゼロ値がセットされる）。まぁ，当たり前だよね。

ところが ageMap[x] の評価結果を (uint, bool) の組（tuple）で受けることもできるのだ¹。これによってコードを

package main

import "fmt"

func main() {
    ageMap := map[string]uint{
        "Alice": 18,
        "Teles": 20,
    }
    if age, ok := ageMap["Selene"]; ok {
        fmt.Println(age)
    } else {
        fmt.Println("unknown")
    }
    // Output
    // unknown
}

と書き換えることでき， ageMap[x] の評価に失敗した際の挙動を記述できる。 Go の言語仕様では，これを「特殊形式（special form）」と呼んでいる（日本語が怪しいのはご容赦）。

言語仕様を眺めてみると，この特殊形式が適用可能なのは以下の3つのみのようだ。

#	Expressions	Normal Form	Special Form
1	Index Expression on Map	`foo := bar[x]`	`foo, ok := bar[x]`
2	Type Assertion	`foo := bar.(T)`	`foo, ok := bar.(T)`
3	Receive Expression	`foo := <-ch`	`foo, ok := <-ch`

最初のはインデックス値 x が map にない場合に false になる。 2番目は型 T でのアサーションに失敗した場合に（panic を吐くことなく） false になる。最後のはチャネル ch が閉じている場合に false になる。

他の式評価や関数の返り値ではこのようなことはできない。たとえば slice のインデックス式評価に特殊形式はない。インデックス値が範囲外なら単に panic が投げられるだけだ。

実は，特殊形式が上の3つの式評価でしか適用されないというのが分からなくて「どうして普通の関数の返り値とかではできないんだろう」とひとしきり悩んだことがあったのだった。言語仕様を読めっての（笑）

ブックマーク

参考図書

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

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

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

厳密には，特殊形式 (T, bool) の2要素目は型付けなしの真偽値（untyped boolean）に評価される。「型付けなし（untyped）」というのは Go 特有の概念だそうで，具体的な型が決定される前の状態を指す。たとえば，定数 math.Pi は10進数64桁の小数点数で定義されている。型付けなし定数については『プログラミング言語Go』の3.6.2章にも解説がある。 ↩︎

次期 Go 言語で導入される総称型について予習する（その3）

2020-09-26T14:21:12+00:00

【2021-02-21 追記】 型パラメータの提案（「総称型」というのは厳密には正しくないらしい）は2021年2月に承認され，製造フェーズに入ったようだ。

前回紹介した “Type Parameters - Draft Design” が 2020-09-21 にアップデートされたらしい（最終更新：2020-11-25）。どうやらこれが最終案になりそうだ。

早ければ2021年8月にリリース予定の Go 1.17 でお披露目というスケジュールは変わらない模様。また総称型（generics）に対応した Playground も最終案の仕様で稼働中である。

https://go2goplay.golang.org/

前回からの変更点

前回は，たとえば

type ordered interface {
	type int, int8, int16, int32, int64,
		uint, uint8, uint16, uint32, uint64, uintptr,
		float32, float64,
		string
}

func Max(type T ordered)(x, y T) T {
    if x < y {
        return y
    }
    return x
}

のような記述だったが，今回は型パラメータ（type parameter）の記述がちょっと変わったようで

type ordered interface {
	type int, int8, int16, int32, int64,
		uint, uint8, uint16, uint32, uint64, uintptr,
		float32, float64,
		string
}

func Max[T ordered](x, y T) T {
	if x < y {
		return y
	}
	return x
}

と角括弧 [...] で囲まれている。どうしても山括弧 <...> はイヤみたい（笑）

type キーワードは無用となった。

組込み済みの制約

組込み済みの interface 型として error が定義されているように，組込み済みの制約（constraint）として any と comparable が追加されるようだ。

any はあらゆる型を包摂する。むしろ「制約がない」ことを示す制約というべきか。強いて書くなら

type any interface{}

といったところだろうか。たとえば

// Print prints the elements of any slice.
// Print has a type parameter T and has a single (non-type)
// parameter s which is a slice of that type parameter.
func Print[T any](s []T) {
    for _, v := range s {
		fmt.Println(v)
	}
}

via Type Parameters - Draft Design

みたいな感じに使える。どうやら型パラメータの指定で制約を省略することはできないようなので，制約がない場合は any を付けることになりそうだ。

comparable は演算子 == および !== が使える型を示す制約だ。これを使って

package main

import "fmt"

func Contains[T comparable](col []T, item T) bool {
	for _, e := range col {
		if e == item {
			return true
		}
	}
	return false
}

func main() {
	fmt.Println(Contains([]string{"coffee", "tea"}, "coffee")) //true
	fmt.Println(Contains([]int{1, 2, 3}, 11))                  //false
	fmt.Println(Contains([]int{1, 2, 3}, 1))                   //true
}

via Go Generics draft design Final

のように書ける。

any も comparable も制約としてのみ使用可能で，通常の inteface 型としては使えないようだ。

なお， Go の総称型について詳しくは以下の「本」がオススメである。色々な事例が載っているのでかなり参考になる。

Go 言語にやってくる Generics は我々に何をもたらすのか | Zenn

この本を買うために Zenn のアカウントを取ってもいいかも（クレカが通ればだけど）。

Go は Nearly Java になるか

上述の「本」に

その慎重な Go が今、Generics を取り入れ、Better C から Nearly Java へと変わろうとしています。Java がそうであった様に、Go は Generics の導入により多くのアルゴリズムが汎用的に実装され便利になっていくでしょう

Go 言語にやってくる Generics は我々に何をもたらすのかより

とある。標準の sort パッケージのように型ごとに似たようなコードをゴリゴリ書くのではなく，汎化されたアルゴリズムに集約されていく期待感はあるが，それが Nearly Java になるかについては懐疑的である。

Go 言語の特徴のひとつは「汎化」の実装として Java や Rust のような公称型の部分型付け（nominal subtyping）ではなく構造型の部分型付け（structural subtyping）を採用していることにある。当然ながらこれは総称型を使ったアルゴリズムの実装にも大きな影響を与える筈である。

私は 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 言語で導入される総称型について予習する（その2）

2020-06-17T07:33:04+00:00

以前書いた記事に関して，仕様が変わったらしい。

そこで，これまでのおさらいと変更点について簡単に紹介する。

「総称型」のおさらい

次期 Go 言語で導入される「総称型（generics）」について，これまで提案されていた仕様は以下の通り。

contract ordered(t T) {
    t < t
}

func Max(type T ordered)(x, y T) T {
    if x < y {
        return y
    }
    return x
}

Max() 関数の (type T ordered) の部分が「型パラメータ（type parameter）」で，これによって型 T が総称型であることを示す。また ordered は「型コントラクト（type contract）」と呼ばれ，総称型に対する制約（constraint）として機能している。

制約の定義

新しい提案では，型コントラクトを捨て，制約の定義を以下のように変更する。

type ordered interface {
	type int, int8, int16, int32, int64,
		uint, uint8, uint16, uint32, uint64, uintptr,
		float32, float64,
		string
}

func Max(type T ordered)(x, y T) T {
    if x < y {
        return y
    }
    return x
}

以前の型コントラクトとの違いは 既存のキーワードがそのまま使える ことである。文法も interface 型の宣言とほぼ同じだが type int, int8, ... といった感じに型の列挙ができる点がこれまでと異なる。

これにより，制約 ordered を満たす型であれば

func main() {
	fmt.Println(Max(Max(1, 2), 3))               //Output: 3
    fmt.Printf("%#U\n", Max(Max('あ', 'い'), 0)) //Output: U+3044 'い'
}

などと記述できる。

なお，これまでの interface 型も制約として使える。たとえば，こんな感じ。

func SayError(type E error)(e E) string {
	return e.Error()
}

func main() {
	fmt.Println(SayError(io.EOF)) //Output: EOF
}

更に interface 型を入れ子にすることで複雑な制約条件を構成することもできる。

注入するか単態化するか

ところで先程の

func SayError(type E error)(e E) string {
	return e.Error()
}

は，わざわざ総称型を使わなくとも今までの書き方で

func SayError(e error) string {
	return e.Error()
}

としても見た目の結果は同じになる。

しかし，今までの書き方が実行時に動的ディスパッチを行う「依存の注入（depencency injection）」であるのに対し，総称型を使った記述はコンパイル時に型ごとに別々の関数として展開される。これを「単態化（monomorphization）」と呼ぶ。

依存の注入と単態化ではリソース管理の戦略がまるで異なる。

たとえば上述の SayError() 関数を総称型で記述するのは，どう考えても効率が悪い。 error に包摂される型は必要に応じていくらでも定義可能であり，それらの型ごとに単態化されるなどぞんぞがさばる。

逆に Max() 関数なんかは，基本型の振る舞いを interface で括るのが難しいこともあり，コストの高い float64 型の math.Max() くらいしか標準では実装されてなかったりする。こういったものを総称型で記述できるようになれば（OAOO 原則の観点から考えても）コード管理しやすくなるだろう。

「Go プログラマは息をするように依存を注入する」。他のプログラミング言語が総称型で書いているかなりの部分を依存の注入で簡単に纏めてしまえるのが Go 言語の強みであるが，使える道具は多いに越したことはない。

Go 2 Playground

次期 Go 言語用に新しい Playground が公開されている。

https://go2goplay.golang.org/

総称型についてもここで色々と試せるようなので，遊びに行ってみてはいかがだろうか。

早ければ Go 1.17 でお披露目？

だいぶ仕様が固まってきた総称型であるが，早ければ2021年8月にリリース予定の Go 1.17 でお披露目されるかもしれないとのこと。

たのしみ！

ブックマーク

参考図書

プログラミング言語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)

それは Duck Typing ぢゃない（らしい）

2020-04-10T10:37:23+00:00

今回は Go と Rust との比較をちょっとポエミーに語ってみる（笑）

そもそも duck typing は Ruby のような動的型付け言語における型推論の手法（のひとつ）である。その由来は duck test から来ていて

If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

via Duck test - Wikipedia

というフレーズに集約されている。

静的型付け言語である Go や Rust における抽象型を使った型決定を duck typing と呼ぶのは厳密には正しくない，らしい。 Go や Rust における interface や trait といった抽象型を用いた型決定は「部分型付け（subtyping）」と呼ばれる。ただし Go と Rust では全く異なる戦略をとる。

Cat コマンドもどき（Go 版）

ここで簡単なプログラムを書いてみよう。 UNIX 系のプラットフォームではおなじみの cat コマンドの「もどき」を書いてみる。

本来の cat コマンドは複数の入力を結合（concatenate）して出力するものだが，真面目な実装をし始めるとキリがないので，今回は以下の2つの機能のみ実装する。

コマンドライン引数で指定したファイルを1つのみ標準出力に出力する
ファイルの指定がない場合は標準入力をそのまま標準出力に出力する

ぶっちゃけ，ただの「土管」である（笑）これを Go で書いたのが以下のコードだ。

package main

import (
    "fmt"
    "io"
    "os"
)

func concatenate(w io.Writer, r io.Reader) error {
    _, err := io.Copy(w, r)
    return err
}

func main() {
    if len(os.Args) > 1 {
        file, err := os.Open(os.Args[1])
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            return
        }
        defer file.Close()

        if err := concatenate(os.Stdout, file); err != nil {
            fmt.Fprintln(os.Stderr, err)
            return
        }
    } else {
        if err := concatenate(os.Stdout, os.Stdin); err != nil {
            fmt.Fprintln(os.Stderr, err)
            return
        }
    }
}

concatenate() 関数がメインのロジックで，引数の io.Writer, io.Reader および返り値の error は全て interface 型である。まぁ concatenate() 関数を括り出す必然性は全くないのだが，後述の Rust のコードと比較しやすいよう敢えて分けている。

concatenate() 関数の呼び出しで，最初の

if err := concatenate(os.Stdout, file); err != nil {
    fmt.Fprintln(os.Stderr, err)
    return
}

と次の

if err := concatenate(os.Stdout, os.Stdin); err != nil {
    fmt.Fprintln(os.Stderr, err)
    return
}

は（当然ながら）同じ関数で，引数や返り値にどのようなインスタンスが入るかは実行時に決まる。コンパイル時に決まるのは注入するインスタンスの構造が受け入れる interface 型の構造と合致していることだけだ（合致しなければコンパイル・エラー）。

すンごい簡単に書かれているけど，これは「依存の注入（depencency injection）」の典型例である。

では，これをリファレンスとして，今度は Rust を使って書いてみる。

Cat コマンドもどき（Rust 版，総称型編）

とりあえず，えいやっで書いたコードがこちら。

fn concatenate<W, R>(w: &mut W, r: &mut R) -> Result<(), std::io::Error>
where
    W: std::io::Write,
    R: std::io::Read,
{
    let mut buf = Vec::new();
    r.read_to_end(&mut buf)?;
    w.write_all(&buf)?;
    Ok(())
}

fn main() -> Result<(), std::io::Error> {
    let args = std::env::args();
    if args.len() > 1 {
        for s in args.skip(1).take(1) {
            concatenate(
                &mut std::io::stdout(),
                &mut std::io::BufReader::new(std::fs::File::open(s)?),
            )?;
        }
    } else {
        concatenate(&mut std::io::stdout(), &mut std::io::stdin())?;
    }
    Ok(())
}

std::io::Write と std::io::Read が trait 型なのだが，各 trait は総称型 W, R の制約条件として書かれているだけで実行時に機能するわけではない。つまり最初の

concatenate(
    &mut std::io::stdout(),
    &mut std::io::BufReader::new(std::fs::File::open(s)?),
)?;

と次の

concatenate(&mut std::io::stdout(), &mut std::io::stdin())?;

はコンパイル時に別の関数として展開される¹。これを（多態化（polymorphization）に対する）単態化（monomorphization）と呼ぶ。

じゃあ Rust では依存の注入は書けないのかというと，勿論そんなことはない。

Cat コマンドもどき（Rust 版，依存注入編）

依存の注入ができるように書き換えたバージョンがこれ。

fn concatenate(
    w: &mut Box<dyn std::io::Write>,
    r: &mut Box<dyn std::io::Read>,
) -> Result<(), Box<dyn std::error::Error>> {
    let mut buf = Vec::new();
    r.read_to_end(&mut buf)?;
    w.write_all(&buf)?;
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = std::env::args();
    let mut r: Box<dyn std::io::Read> = if args.len() > 1 {
        let fnam = match args.skip(1).next() {
            Some(s) => s,
            _ => "".to_string(),
        };
        Box::new(std::io::BufReader::new(std::fs::File::open(fnam)?))
    } else {
        Box::new(std::io::stdin())
    };
    let mut w: Box<dyn std::io::Write> = Box::new(std::io::stdout());
    concatenate(&mut w, &mut r)?;
    Ok(())
}

concatenate() 関数が同一のものであることを強調するために呼び出しをひとつに纏めているので少しまだるこしい書き方になっているが，ご容赦。このように Rust では trait 型を Box<dyn Trait> の形式に落とし込むことで実行時の動的ディスパッチを可能にしている。

Accept Interfaces, Return Structs

Go の設計指針で有名な言葉に accept interfaces, return structs というのがある。私自身は必ずしもこれに賛同しないが（システム内部のコンテキスト境界は interface にすべき），この指針は Go の特徴をよく表している。

たとえば io.Reader と os.File は Read() 関数という「同じ振る舞いを持つ」点で関連しているけど，両者の間に明示された記述は存在しない²。それでも，その関係を以って io.Reader に os.File インスタンスを注入可能であり「Go では duck typing ができる」とか言われる所以である。 Go プログラマは息をするように依存を注入するのだ。

このような関係を構造型の部分型付け（structural subtyping）と呼ぶそうな。

構造型と公称型

Go の interface 型が構造型の部分型付けであるのに対し Rust の trait 型は公称型の部分型付け（nominal subtyping）に分類されるだろう。たとえば std::io::Read と std::fs::File との間にはコード上で明示された関連がある。その「明示された関連」がなければ，たとえ同じ構造を持っていたとしても，両者の間に関係があるとは見なされないのだ。

Rust の言語仕様がこのような制約を構成しているのには，勿論ちゃんとした理由がある。

Go においてはメモリ管理や並列処理³ といった面倒事をランタイム・モジュールに「丸投げ」している。なので，プログラマは富豪的な記述に専念できるが，バイナリは肥大化してしまうしコンパイル時の最適化にも限度がある⁴。

Rust はリソース管理等についてプログラマ側でかなり面倒を見なければならないが（それでも C/C++ などに比べれば全然楽だし安全），言い換えればコード上でのコントロールがし易くコンパイル時の最適化についても期待できる。上述の cat コマンドもどきでも，コンパイル時の単態化を避けるコードをわざわざ書く理由はないだろう。

これはプログラム設計時の重要なトレードオフとなる。まぁ「Go か Rust か」みたいな究極の選択をする状況はないと思うが，複数のプログラミング言語からどれかを選ぶ際にはこういったことも考慮していくべきだ（選ぶ余裕もない事案のほうが多いだろうけどw）。

前にも書いたが，「それができる」ことと「そのように作られている」ことには天と地ほどの違いがある。どうせ「書く」なら無茶せず楽しく書きたいものである。

ブックマーク

Rustでファイルの入出力 - Qiita
RustのファイルI/OにはBufReader, BufWriterを使いましょう、という話 - Qiita
Go言語のInterfaceの考え方、Accept interfaces,return structs - Qiita
継承できないなら注入すればいいじゃない！ : Go のイベント用に作ったスライド

参考図書

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

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

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

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

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

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

余談だが Rust では「ファイルを閉じる」操作は変数の生存期間満了時に暗黙的に行われるようだ。明示的に閉じるには drop 関数を使う。 ↩︎
たとえば var _ io.Reader = (*os.File)(nil) のような記述で関連を明示することは可能。これはパッケージを書く際によく用いられる手法で，実行バイナリには反映されないが，事実上のコンパイラ・ヒントとして機能する。 ↩︎
Go における並行処理と並列処理の違いについては『Go言語による並行処理』を読むことを強くおすすめする。 ↩︎
近年，特に組込み用途で注目されている TinyGo は LLVM 上で動作することを前提としていて，本家 Go に比べてかなり小さい実行バイナリを吐けるらしい。 ↩︎

Rust の型に関する覚え書き

2020-04-08T07:33:06+00:00

この記事では Rust の型（type）に関することを思いつくまま脈絡なく書き記しておく。随時更新予定。

組み込みデータ型

組み込みデータ型には大きく分けてスカラ型と複合型がある。

スカラ型

スカラ型はスカラ値を有する型である。型によって値のサイズが決まっていて，受け渡しは copy semantics で行われる。

スカラ型に分類される型は以下の通り。

1. 整数型

サイズ	符号あり	符号なし
8 bits	`i8`	`u8`
16 bits	`i16`	`u16`
32 bits	`i32`	`u32`
64 bits	`i64`	`u64`
—	`isize`	`usize`

isize/usize のサイズはアーキテクチャに依存する¹。また，リテラル表記時等での型推測の既定は i32 型となる²。

let x = 123; //type i32

ただしリテラル表記の後ろに型名を付けることで型を指定することが可能。

let x = 123i64; //type i64

もちろん変数に型注釈を付けて明示することも可能。

let x: u8 = 123; //type u8

2. 浮動小数点数型

サイズ	型名	既定
32 bits (仮数部 23 bits)	`f32`
64 bits (仮数部 52 bits)	`f64`

型の推定・評価は整数型と同じで，リテラル表記時等での型推測の既定は f64 型となる³。

let x = 1.23; //type f64

3. 文字型

文字型 char は Unicode 符号点を示す。リテラル表記はこんな感じ。

let c = '♡';

Rust における文字列と文字の関係については「Rust の文字列操作（1）」を参照のこと。

4. 論理値型

論理値型 bool は true と false の2値のみ取り得る。

複合型

複合型は複数の要素を組み合わせた型で，タプル型と配列型がある。

複合型は定義毎に型と要素数が決まっている。要素の型が全てスカラ型であれば copy semantics で値の受け渡しが可能。

1. タプル型

タプル型は（名前の通り）複数の型を組み合わせた型で，こんな感じに記述できる。

fn main() {
	let tup = (500, 6.4, 1u8);
    println!("tup = {:?}", tup); //Output: tup = (500, 6.4, 1)
}

2. 配列型

配列型は，単一の型で構成される複数要素の型で⁴，こんな感じに記述できる。

fn main() {
	let ary = [1, 2, 3];
	println!("ary = {:?}", ary); //Output: ary = [1, 2, 3]
}

型エイリアス

型の別名定義。名前は変わっても機能は変わらない。総称型と組み合わせると吉？

type Strings = Vec<String>;

fn main() {
    let planets: Strings = vec![
        "Mercury".to_string(),
        "Venus".to_string(),
        "Earth".to_string(),
        "Mars".to_string(),
    ];
    planets.iter().for_each(|p| {
        println!("{}", p);
    });
}

構造体

0個以上のフィールド（型と名前）を含むデータ構造
構造体に紐づく関連関数およびメソッドを実装可能
トレイトからの実現（realization）が可能。構造体間の継承（inheritance）は不可

struct Planet {
	name: String,
    mass: f64,
    distance: f64,
}

構造体のインスタンス化

リテラル表現を使ったインスタンス化。

#[derive(Debug)]
struct Planet {
    name: String,
    mass: f64,
    distance: f64,
}

fn main() {
    let p = Planet {
        name: "Earth".to_string(),
        mass: 1.0,
        distance: 1.0,
    };
    println!("{:?}", p); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
}

インスタンス化関数を実装してみる。

#[derive(Debug)]
struct Planet {
    name: String,
    mass: f64,
    distance: f64,
}

impl Planet {
    fn new(s: &str, mass: f64, distance: f64) -> Planet {
        Planet {
            name: s.to_string(),
            mass,
            distance,
        }
    }
}

fn main() {
    let p = Planet::new("Earth", 1.0, 1.0);
    println!("{:?}", p); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
}

構造体のコピー

コピー用のメソッドを書いてみた。

impl Planet {
    fn copy(&self) -> Planet {
        Planet {
            name: self.name.clone(),
            ..*self
        }
    }
}

あるいは derive 構文を使って Clone トレイトから clone() メソッドを自動生成する。

#[derive(Debug, Clone)]
struct Planet {
    name: String,
    mass: f64,
    distance: f64,
}

fn main() {
    let p = Planet::new("Earth", 1.0, 1.0);
    let cpy = p.clone();
    println!("{:?}", p); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
    println!("{:?}", cpy); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
}

なお String 等の Copy トレイトを実装できないフィールドを含む構造体は Copy トレイトを実装できないため，代入構文で値のコピーが発生しない。この場合は move semantics により所有権が移動する。

タプル構造体

構造体の特殊なパターンで，名前のないフィールドを定義する。フィールドがタプルで定義される以外は通常の構造体と同じ。関連関数およびメソッドも実装可能。

#[derive(Debug, Copy, Clone)]
struct Point(i64, i64);

impl Point {
    fn new(x: i64, y: i64) -> Point {
        Point(x, y)
    }
}

fn main() {
    let p1 = Point(1, 2);
    let p2 = Point::new(3, 4);
    let p3 = p1; //copy semantics
    println!("{:?}", p1); //Output: PPoint(1, 2)
    println!("{:?}", p2); //Output: PPoint(3, 4)
    println!("{:?}", p3); //Output: PPoint(1, 2)
}

列挙型

Rust の列挙型 enum はどちらかというと関数型プログラミング言語の影響を強く受けているらしい。

enum VariantType {
    Int(i32),
    Float(f64),
    Text(String),
}

列挙型の評価には match 式を用いる。

fn main() {
    let list: Vec<VariantType> = vec![
        VariantType::Int(123),
        VariantType::Float(1.23),
        VariantType::Text("hello".to_string()),
    ];

    list.iter().for_each(|e| {
        match e {
            VariantType::Int(v) => println!("{:#x}", v), //Output: 0x7b
            VariantType::Float(v) => println!("{:e}", v), //Output: 1.23e0
            VariantType::Text(v) => println!("{:?}", v), //Output: "hello"
        };
    });
}

列挙型も構造体と同じく関連関数やメソッドを実装できる。

impl VariantType {
    fn is_integer(&self) -> bool {
        match self {
            VariantType::Int(_) => true,
            _ => false, //others
        }
    }
}

fn main() {
    let list = vec![
        VariantType::Int(123),
        VariantType::Float(1.23),
        VariantType::Text("hello".to_string()),
    ];

    list.iter().for_each(|e| {
        println!("Is {:?} an integer?: {}", e, e.is_integer());
    });
}

総称型

Rust ではオブジェクトの抽象化の手段として総称型をサポートしている。

関数における総称型

以下の max() 関数で使われる型 T が総称型と呼ばれているもの。

fn max<T: std::cmp::PartialOrd>(left: T, right: T) -> T {
    if left >= right {
        left
    } else {
        right
    }
}

fn main() {
    let x = 1;
    let y = 2;
    println!("max({}, {}) = {}", x, y, max(x, y)); //Output: max(1, 2) = 2
}

<T: std::cmp::PartialOrd> の表現は型 T の制約条件を示すもので std::cmp::PartialOrd トレイトを実装する型のみ max() 関数が有効になる。このようなトレイトを使った制約の定義を「トレイト境界（trait bound）」と呼ぶらしい。

トレイト境界は where 節を使って記述することもできる。

fn max<T>(left: T, right: T) -> T
where
    T: std::cmp::PartialOrd,
{
    if left >= right {
        left
    } else {
        right
    }
}

トレイト境界の記述は煩雑になりがちなので，これで多少はスッキリするだろう。

ちなみに std::cmp::PartialOrd トレイトは >, >=, <, <= の順序比較演算子を使うためのもので，少なくとも組み込みデータ型は全て std::cmp::PartialOrd トレイトを実装している。

たとえば比較可能でない構造体

#[derive(Debug)]
struct Person {
    age: u32,
    name: String,
}

に max() 関数を使おうとしても

fn max<'a, T: std::cmp::PartialOrd>(left: &'a T, right: &'a T) -> &'a T {
    if left >= right {
        left
    } else {
        right
    }
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    let p2 = Person {
        age: 24,
        name: "Bob".to_string(),
    };
    println!("max({:?}, {:?}) = {:?}", p1, p2, max(&p1, &p2)); //Error: can't compare `Person` with `Person`
}

コンパイルエラーになる。

構造体における総称型

構造体のフィールドやメソッドも総称型で記述することができる。

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: std::ops::Add<Output = T> + Copy> Point<T> {
    fn add(&self, p: &Self) -> Self {
        Self::new(self.x + p.x, self.y + p.y)
    }
}

impl<T: std::fmt::Display> std::fmt::Display for Point<T> {
    fn fmt(&self, dest: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(dest, "<{}, {}>", self.x, self.y)
    }
}

fn main() {
    let p1 = Point::new(1, 2);
    let p2 = Point::new(3, 4);
    println!("{} + {} = {}", p1, p2, p1.add(&p2)); //Output: <1, 2>
}

上述のように impl 構文毎に個別にトレイト境界を設定できる。

列挙型における総称型

列挙型も構造体と同じように総称型が使える。列挙型と総称型の組み合わせでもっとも有名なのが Result 型だろう。

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

参考図書

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

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

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); 評価

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

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

isize/usize は C 言語等でいう int と同じと思って構わない。まぁ，どちらかと言うと size_t みたいな感じかもしれないけど。 ↩︎
現在のアーキテクチャの主流が 64 bits にも関わらず整数型の既定が i32 なのは， 32 bits アクセスのほうが「速い」かららしい。 ↩︎
浮動小数点数型の場合，単精度（f32）と倍精度（f64）の間でパフォーマンス上の違いは殆どないそうだ。それならサイズが大きい方を既定にすればいいよね，ってことらしい。 ↩︎
配列型でも列挙型（enum）と組み合わせることで複数の型に対応させることは可能。 ↩︎

Go 言語で Factory Method Pattern を構成できるか

2018-12-30T06:24:48+00:00

少し前に面白い記事を見かけたのだが

Go言語で factory method パターンを書いてみる - Qiita

「これって factory method pattern じゃないよね」と思いつつ「Go 言語には「継承」がない」ことを説明する好例だと気付いたので今回の記事を書いてみた。

Factory Method Pattern とは

まずは factory method pattern の解説から。以下にクラス図を示す。

Product は抽象クラスで ConcreteProduct が Product の実装クラスである。 Creator クラスの factoryMethod() メソッドは Product インスタンスを返す抽象メソッドで，サブクラスの ConcreteCreator で実装されている。

Creator クラスを利用する側はサブクラスの ConcreteCreator を Creator クラスとして生成し anOperation() メソッドをキックする。

ポイントは anOperation() メソッドが実装メソッドで，内部では factoryMethod() メソッドが呼ばれている点である。ただし Creator インスタンスの実体は ConcreteCreator クラスなので， anOperation() メソッドから呼ばれるのはオーバーライドされた ConcreteCreator のほうの factoryMethod() であることが期待される，というわけだ。

本来なら Creator インスタント生成時にどの ConcreteProduct インスタンスを（Product クラスとして）使うのか判断すればいいのだが（これが factory pattern），それだと ConcreteProduct クラスが増えるたびに Creator クラスも修正しなければならず管理が煩雑になる。

そこで ConcreteProduct クラスと一対一に対応する ConcreteCreator クラスをつくり，その中でどの ConcreteProduct インスタンスを（Product クラスとして）使うのか判断している，つまり「インスタンス作成をサブクラスにまかせる」のである。

Go 言語には「継承（Inheritance）」がない

しかし，このデザイン・パターンは Go 言語では使えない。何故なら「Go 言語には「継承」がない」からである。

汎化と構造的部分型（Structural Subtyping）

Go 言語ではクラス間の「汎化」関係を実装する手段として interface 型を持っているが，これは「振る舞い」のみを定義する。先程の Creator クラスのように抽象メソッドと実装メソッドをひとつのクラスの中に混ぜ込むことはできない。 Interface のような型を一般的には「構造的部分型」と呼ぶらしい¹。

埋め込み（Embedding）と委譲（Delegation）

もうひとつ Go 言語には型を構造体のフィールドとして埋め込む機能がある。たとえば

type parent struct{}

という型があるとして

type child struct {
    parent
}

とすれば child 型は parent 型の属性や操作をそのまま使うことができる。こんな感じ。

package main

import "fmt"

type parent struct{}

func (p parent) Say() string {
    return "I'm parent type."
}

type child struct {
    parent
}

func main() {
    p := parent{}
    c := child{}
    fmt.Println(p.Say())
    fmt.Println(c.Say())
    //Output:
    //I'm parent type.
    //I'm parent type.
}

これで child 型は parent 型を（擬似的に）継承しているように見える。更に child 型に対して

func (c child) Say() string {
    return "I'm child type."
}

という関数を追加すれば

package main

import "fmt"

type parent struct{}

func (p parent) Say() string {
    return "I'm parent type."
}

type child struct {
    parent
}

func (c child) Say() string {
    return "I'm child type."
}

func main() {
    p := parent{}
    c := child{}
    fmt.Println(p.Say())
    fmt.Println(c.Say())
    //Output:
    //I'm parent type.
    //I'm child type.
}

という感じになり child 型の Say() 関数が parent 型の Say() 関数をオーバーライドしているように見える。ところが parent 型に

func (p parent) Speek() {
    fmt.Println(p.Say())
}

という関数を追加し，これを使って喋らせてみると

package main

import "fmt"

type parent struct{}

func (p parent) Say() string {
    return "I'm parent type."
}

func (p parent) Speek() {
    fmt.Println(p.Say())
}

type child struct {
    parent
}

func (c child) Say() string {
    return "I'm child type."
}

func main() {
    c := child{}
    fmt.Println(c.Say())
    c.Speek()
    //Output:
    //I'm child type.
    //I'm parent type.
}

となり Speek() 関数はあくまでも parent 型の Say() 関数を呼び出していることが分かる。

実は Go 言語の埋め込みフィールドは「継承」ではなく「委譲」として機能する。したがって C++ や Java の仮想関数のようにメソッドがオーバーライドされることもない。型の中で関数名が被った際の暗黙の優先順位は決められているためオーバーライドしているように見えるだけなのである。

これを先程の factory method pattern のクラス図に当てはめて考えると Go 言語で無理やり実装しようとしても

という感じになり，そもそも Creator を抽象クラスに（polymorphic に）できないし，サブクラスの ConcreteCreator から anOperation() メソッドを呼び出しても内部で呼び出される factoryMethod() メソッドは Creator クラスのものということになる。

「継承」できないなら「注入」すればいいじゃない

さて，どうしようか。とりあえずコードを書きながら考えてみよう。

最初に紹介した記事を参考にしつつ，まずは Product に相当する interface 型を以下のように定義するところから始めようか。

//Human is Product class of factory method pattern
type Human interface {
    SelfIntroduction() string
}

続いて ConcreteProduct に相当する型も定義する。

//NamedHuman is parent class with name property
type NamedHuman struct {
    MyName string
}

func (nh NamedHuman) Name() string {
    if len(nh.MyName) == 0 {
        return "〈名無し〉"
    }
    return nh.MyName
}

//Man is Concrete Product class of factory method pattern
type Man struct {
    NamedHuman
}

func (hm Man) SelfIntroduction() string {
    return hm.Name() + "だぜ！"
}

//woman is Concrete Product class of factory method pattern
type Woman struct {
    NamedHuman
}

func (hm Woman) SelfIntroduction() string {
    return hm.Name() + "よ！"
}

ちょっと分かりにくいかも知れないが，クラス図にすると

となっていて Man 型および Woman 型が（Human 型に対する） ConcreteProduct クラスに相当するのが分かると思う。ちょろんと動かしてみよう。

func NewMan(name string) Human {
    m := &Man{}
    m.MyName = name
    return m
}
func NewWoman(name string) Human {
    w := &Woman{}
    w.MyName = name
    return w
}
func main() {
    h1 := NewMan("太郎")
    h2 := NewWoman("花子")
    fmt.Println(h1.SelfIntroduction())
    fmt.Println(h2.SelfIntroduction())
    //Output:
    //太郎だぜ！
    //花子よ！
}

問題なく動作することが確認できた。

ここまで書いたコードを眺めてみると NewMan() および NewWoman() 関数が factoryMethod() メソッドと似た機能を有していることが分かる。じゃあ，これらの関数を実行時に Creator クラスに埋め込むように構成すればいんじゃね？

さっそく書いてみよう。

//Speaker is Creator class of factory method pattern
type Speaker struct {
    createHuman func(string) Human
}

func (s Speaker) Speech(name string) {
    hm := s.createHuman(name)
    fmt.Println(hm.SelfIntroduction())
}

createHuman は関数型のメンバ変数で func(string) Human のインタフェースを持つ関数を表す。これはすなわち NewMan() および NewWoman() 関数のことである。

それでは実際に動かしてみよう。

func NewSpeeker(f func(string) Human) *Speaker {
    return &Speaker{createHuman: f}
}

func main() {
    s1 := NewSpeeker(NewMan)
    s2 := NewSpeeker(NewWoman)
    s1.Speech("太郎")
    s2.Speech("花子")
    //Output:
    //太郎だぜ！
    //花子よ！
}

よーし，うむうむ，よーし。クラス図にするとこんな感じだろうか（factory method pattern のクラス図と比較してみよう）。

これってだいぶ不格好だけど，まさしく依存（オブジェクト）の注入（dependency injection pattern）だよね²。

ていうか Go 言語プログラマは error 型や標準パッケージの io.Reader などを通じて息をするように「依存の注入」を行っているわけで，「継承できないなら注入すればいいじゃない」という感じで，自国語に得意なパターンへ持ち込むのが得策だと思う。

ブックマーク

Factory Method パターン - Wikipedia : クラス図はこちらを参考にした
Dependency injection - Wikipedia : 英語版と日本語版でかなり内容が異なるのだが大丈夫か？
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)

増補改訂版 Java言語で学ぶデザインパターン入門: 結城浩 (著); SBクリエイティブ 2004-06-18 (Release 2014-03-12); Kindle版; B00I8ATHGW (ASIN); 評価

[Comment] 結城浩さんによる通称「デザパタ本」。 Java 以外でも使える優れもの。

reviewed by Spiegel on 2016-01-05 (powered by PA-APIv5)

Interface 型の性質を示すものとして duck typing がよく挙げられる。私も以前はそう思っていたが duck typing は動的型付き言語で型を決定する手法（のひとつ）を指すのだそうだ。もちろん Go 言語は静的型付き言語なのでこれに当てはまらない。じゃあ Go 言語の interface 型は何かというと「構造的部分型」と呼ぶのが正しいようだ。 ↩︎
私は dependency injection を「依存性の注入」と訳すことに懐疑的だという主張に同意します。 ↩︎

次期 Go 言語で導入される（かもしれない）総称型について予習する

2018-11-10T21:10:48+00:00

2018年8月に次期 Go 言語で追加される（かもしれない）仕様についてアナウンスがあった。

Go 2 Drafts Announcement - YouTubeより

“Go 2” といってもメジャー・バージョンが変わるのではなく現行バージョンに対する追加仕様らしい。したがって後方互換性は確保されているようだ。

紹介されているドラフト案は大きく2つある。

総称型（generics）
- Generics — Problem Overview
- Contracts — Draft Design
エラー・ハンドリングに関するもの

このうち今回は総称型について予習してみる。

なお “Go 2” の提案はまだドラフト段階なので大幅に変更になったり場合によっては立ち消えになる可能性もある。なので，この記事では深いところまで踏み込まずフワっとした説明になるけど，あしからずご了承の程を。

総称型のメリット

ソフトウェア・エンジニアには自明だと思うが，まずは復習から。

具体例として2つの値のうち大きい方を返す関数を考えてみる。

package main

import "fmt"

func max(x, y int) int {
    if x < y {
        return y
    }
    return x
}

func main() {
    x := 1
    y := 2
    fmt.Printf("max(%v, %v) = %v\n", x, y, max(x, y))
    //Output
    //max(1, 2) = 2
}

この関数 max() は int 型で記述しているが byte 型や float32/float64 型でも関数の中身は全く同じコードになる。

package main

import "fmt"

func max(x, y float64) float64 {
    if x < y {
        return y
    }
    return x
}

func main() {
    x := 1.1
    y := 1.2
    fmt.Printf("max(%v, %v) = %v\n", x, y, max(x, y))
    //Output
    //max(1.1, 1.2) = 1.2
}

ならば，最初から汎化した型で単一のコード記述すれば型ごとに複数のコードを量産しなくてもいんじゃね？という発想になる¹。これが総称型の原点である。

たとえば Java で総称型を使うと以下のような記述になる²。

public static <T> T max(T x, T y) {
    ...
}

<T> の部分が総称型の定義にあたる。ちなみに総称型の名前（この場合は T）はスコープ内で被らなければ任意に指定できる。

現行版 Go 言語において総称型の不在で割りを食っている典型例のひとつが sort パッケージで，基本型の slice のソートだけで以下の型が用意されている³。

sort.Float64Slice
sort.IntSlice
sort.StringSlice

後方互換性を確保するため，これらの型がなくなることはないだろうけど，総称型が実現すれば内部実装の refactoring が進むかも知れない。

このように総称型はコンテナ（container; オブジェクトの集合を表現するデータ構造）操作で特に威力を発揮する。また，現行版 Go 言語では総称型を用いずとも interface 型と reflect パッケージを使ってかなりの部分を代替できるが，コード量のコスト高を別にしても，記述の正しさは実行時での評価ではなくコンパイル時に評価して欲しいところである。

そういうわけで，今までずうっと後回しにされてきたが，総称型を導入できるのであれば是非とも期待したいものである。

型パラメータ（Type Parameter）と型引数（Type Argument）

次期 Go 言語で総称型を導入するために型パラメータおよび型引数の構文を追加するようだ。

例えば先程の max() 関数であれば以下のように記述できる。

package main

import "fmt"

func max(type T)(x, y T) T {
    if x < y {
        return y
    }
    return x
}

func main() {
    x := 1
    y := 2
    fmt.Printf("max(%v, %v) = %v\n", x, y, max(x, y))
    //Output
    //max(1, 2) = 2
}

(type T) の部分が型パラメータで，これによって総称型を定義している。既存の語彙だけで構成しているのがポイント（< や > は演算子だし [...] は配列/slice や map の構文で使われるので避けたのだろう）。

関数を呼び出す側は型推論によって引数の型が一意に決定するので特別な記述は必要ない。相変わらず refatoring に優しい言語だよな（笑）

明示的に型を指定するなら

max(int)(x, y)

などと記述する。 (int) の部分が型引数にあたる。

型宣言とインスタンス生成でも同様に

type List(type T) []T

var listInt = List(int){0, 1, 2, 3, 4 ,5}

などと記述できる。

型コントラクト（Type Contract）

先程の max() 関数だが

func max(type T)(x, y T) T {
    if x < y {
        return y
    }
    return x
}

型 T のインスタンス同士で比較演算（具体的には x < y）が可能である必要がある。たとえば complex64/complex128 は基本型だが < 演算子による比較ができない。

Java の場合は継承を構成して

public static <T extends Comparable<? super T>> T max(T x, T y) {
    ...
}

などと記述することで総称型に対する制約（type constraint）を表現できる⁴。

しかし Go 言語ではいわゆる「継承」の仕組みを持ってないため別のアプローチをとる必要がある。それが型コントラクトである。型コントラクトでは contract キーワードおよびそれを使った構文を追加する。具体的には以下のようなコードになる。

contract comparable(t T) {
    t < t
}

func max(type T comparable)(x, y T) T {
    if x < y {
        return y
    }
    return x
}

なお comparable の型引数を明示する場合は

func max(type T comparable(T))(x, y T) T { ... }

と書く。

型コントラクトの記述はバイナリ・コードにコンパイルされない。上の例では型 T に対して比較演算子 < が使えることを要求しているとコンパイラに知らせるものである。これなら T を complex128 に展開しようとしてもコンパイル時に「契約違反」になるわけだ。

型コントラクトは型コントラクトに埋め込むことができる。例えばこんな感じ。

contract equalable(t T) {
    t == t
}
contract comparable(t T) {
    equalable(T)
    t < t
}

これで comparable は == 演算子と < 演算子が使えることを要求していることになる。

継承を利用した制約と異なり，型コントラクトの自由度は高く応用範囲も広い。たとえばポインタ型を要求するなら

contract pointer(t T) {
    *t
}

などと書くこともできるらしい。他にも io.Reader と汎化・特化の関係があることを要求するなら

contract readable(r T) {
    io.Reader(r)
}

などと書けばいいようだ。

もし今回のドラフト案の通りに総称型が実現するなら型コントラクトの整備が喫緊の作業となるだろう。

ブックマーク

参考図書

プログラミング言語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)

このように同じコードを重複させないように記述するコーディング指針を「OAOO (Once And Only Once) 原則」と呼ぶ。そういえばよくある勘違いで「DRY (Don’t Repeat Yourself) 原則」と解説している記事が見受けられるが， DRY 原則は同じ意味を持つ情報やデータを複数に散らばせないというシステム設計や開発環境の指針を指すものである。 ↩︎
久しぶりに Java コード書いたら型を前置することに違和感がハンパない。型の前置なんて非合理的だよなあ（もちろん偏見w） ↩︎
Slice のソートについてはバージョン 1.8 から任意の型に対応する sort.Slice() 関数が用意された。内部で reflect パッケージを使っているが，かなり巧妙に組まれているため，パフォーマンス低下は殆どないらしい。ただし slice 以外のインスタンスを指定すると（コンパイル時ではなく）実行時に panic を吐く。詳しくは「ソートを使う」を参照のこと。 ↩︎
C++ や C# でも where 句を用いて総称型に対する制約を表現できるが，基本は継承を利用したものである。 ↩︎

Go 1.9 と Type Alias

2017-09-14T01:01:49+00:00

遅ればせながらの記事で申し訳ないが Go 1.9 がリリースされた。

詳しい内容はリリースノートを見ていただくとして，今回の目玉は type alias 機能だろう。

まず type キーワードを使った簡単な足し算を書いてみる。

package main

import (
    "fmt"
)

type Num1 int

func (n1 Num1) Add(n2 Num1) Num1 {
    return n1 + n2
}

func main() {
    n1 := Num1(1)
    n2 := Num1(2)
    fmt.Println(n1.Add(n2))
}

実行結果は 3 と出力されるはずである。ここで “type Num2 Num1" と記述を追加し，この型を使って足し算を行ってみる。

package main

import (
    "fmt"
)

type Num1 int

func (n1 Num1) Add(n2 Num1) Num1 {
    return n1 + n2
}

type Num2 Num1

func main() {
    n1 := Num2(1)
    n2 := Num2(2)
    fmt.Println(n1.Add(n2))
}

これを実行しようとすると

n1.Add undefined (type Num2 has no field or method Add)

とコンパイルエラーになる。何故か。 Num1 と Num2 は異なる型だからだ。型 Num1 に紐付いている関数 Add() は，型 Num2 には紐付かない。継承されないわけだ（Num1 へキャストはできる）。

では今度は “type Num2 = Num1" と記述を変更してみる。

package main

import (
    "fmt"
)

type Num1 int

func (n1 Num1) Add(n2 Num1) Num1 {
    return n1 + n2
}

type Num2 = Num1

func main() {
    n1 := Num2(1)
    n2 := Num2(2)
    fmt.Println(n1.Add(n2))
}

今度はコンパイルエラーにならず 3 と出力される。この “type Num2 = Num1" という構文が type alias を指し，この記述によって Num1 と Num2 は 全く同じ型 として扱われる¹。

なんでこんな妙ちきりんな言語仕様が追加されたかというと，実はこれ，リファクタリングの為に設けられたのである。

Go now supports type aliases to support gradual code repair while moving a type between packages. The type alias design document and an article on refactoring cover the problem in detail.

via Go 1.9 Release Notes

もともと Go 言語はリファクタリングを厚遇する言語と言える。たとえば「構造的部分型（structural subtyping）」などはその最たる例だろう。

きみは Generics がとくいなフレンズなんだね，または「制約は構造を生む」

まぁ，あまり積極的に使う機能ではないかもしれないが，こういうこともできると覚えておくといいだろう。

ブックマーク

参考図書

Java言語で学ぶリファクタリング入門: 結城浩 (著); SBクリエイティブ 2007-01-26 (Release 2014-03-12); Kindle版; B00I8AT1EU (ASIN); 評価

[Comment] 結城浩さんによる「リファクタリング本」の Kindle 版。意外にも Java 以外でも応用できる優れもの。

reviewed by Spiegel on 2018-12-11 (powered by PA-APIv5)

全く同じ型なので継承関係はなく，別名定義した型に独自に関数を紐付けることはできない。ちなみに別パッケージの型に対しても別名定義が可能である： type Time = time.Time ↩︎

1を1億回足して1億にならない場合

2017-01-18T12:45:30+00:00

（この記事は Qiita に投稿した記事の転載です）

今回は軽めのネタで。

C > 浮動小数点型変数はループカウンタとして使用しない - Qiita

まぁ浮動小数点数型の仕様を知れば当たり前の話なのだが，面白そうなので「1を1億回足す」ってのを Go 言語でも書いてみる。

package main

import "fmt"

func main() {
    var d float32 = 0.0
    for i := 0; i < 100000000; i++ {
        d += 1.0
    }
    fmt.Println(d)
}

実行結果は予想通り

$ go run loop1.go
1.6777216e+07

となる¹。念のため float64 でも試してみよう。

package main

import "fmt"

func main() {
    var d float64 = 0.0
    for i := 0; i < 100000000; i++ {
        d += 1.0
    }
    fmt.Println(d)
}

結果は

$ go run loop2.go
1e+08

で，ちゃんと1億になる。 Go 言語では基本型のサイズが厳密に決まってるので（int, uint, uintptr は除く），浮動小数点数型の計算誤差についてもきちんと見積もれるはずである。

ちなみに

package main

import "fmt"

func main() {
    for d := 0.0; d < 1.0; d += 0.1 {
        fmt.Println(d)
    }
}

とすると²

$ go run loop3.go
0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999

ってなことになる³ ので浮動小数点数型の変数をループカウンタにするのは止めましょうね。約束だよ！

math/big パッケージ（追記）

浮動小数点数演算の「情報落ち」や「丸め誤差」等を緩和する方法として math/big パッケージの Float 型を使う手がある。 Float 型では有効桁数を指定できる。たとえば先程の 0.1 ずつカウントアップさせる処理ならこんなコードになる。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    var x, y, z big.Float //zero initialize
    x.SetPrec(128)
    y.SetPrec(128)

    y.SetFloat64(0.1)
    for i := 0; i < 10; i++ {
        z.Add(&x, &y)
        fmt.Printf("z = %v (prec = %d bits)\n", &z, z.Prec())
        x.Set(&z)
    }
}

このコードでは精度を128ビットに揃えて計算している。これを実行するとこうなる。

$ go run big2.go
z = 0.100000000000000005551115123125782702118 (prec = 128 bits)
z = 0.200000000000000011102230246251565404236 (prec = 128 bits)
z = 0.300000000000000016653345369377348106354 (prec = 128 bits)
z = 0.400000000000000022204460492503130808473 (prec = 128 bits)
z = 0.50000000000000002775557561562891351059 (prec = 128 bits)
z = 0.60000000000000003330669073875469621271 (prec = 128 bits)
z = 0.700000000000000038857805861880478914827 (prec = 128 bits)
z = 0.800000000000000044408920985006261616945 (prec = 128 bits)
z = 0.900000000000000049960036108132044319063 (prec = 128 bits)
z = 1.00000000000000005551115123125782702118 (prec = 128 bits)

もうひとつ。 Rat 型を使う手もある。 Rat 型は有理数の内部表現で値を保持するため記述によっては誤差を小さくできる。たとえばこんな感じ。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    x := &big.Rat{} //Zero initialize
    y := big.NewRat(1, 10)

    for i := 0; i < 10; i++ {
        z := (&big.Rat{}).Add(x, y)
        fmt.Printf("z = %s (%v)\n", z.FloatString(20), z)
        x.Set(z)
    }
}

実行結果は以下の通り。

$ go run big3.go
z = 0.10000000000000000000 (1/10)
z = 0.20000000000000000000 (1/5)
z = 0.30000000000000000000 (3/10)
z = 0.40000000000000000000 (2/5)
z = 0.50000000000000000000 (1/2)
z = 0.60000000000000000000 (3/5)
z = 0.70000000000000000000 (7/10)
z = 0.80000000000000000000 (4/5)
z = 0.90000000000000000000 (9/10)
z = 1.00000000000000000000 (1/1)

Decimal 型（追記）

残念ながら Go 言語の標準パッケージには Java で言うところの BigDecimal に相当するものがない。ただし似たパッケージを提供している人はいるようだ。

shopspring/decimal: Arbitrary-precision fixed-point decimal numbers in go

たとえばこんな感じに記述する。

package main

import (
    "fmt"

    "github.com/shopspring/decimal"
)

func main() {
    x := decimal.NewFromFloat(0)
    y, _ := decimal.NewFromString("0.1")

    for i := 0; i < 10; i++ {
        x = x.Add(y)
        fmt.Printf("x = %s\n", x.StringFixed(20))
    }
}

実行結果はこんな感じ。

$ go run big4.go
x = 0.10000000000000000000
x = 0.20000000000000000000
x = 0.30000000000000000000
x = 0.40000000000000000000
x = 0.50000000000000000000
x = 0.60000000000000000000
x = 0.70000000000000000000
x = 0.80000000000000000000
x = 0.90000000000000000000
x = 1.00000000000000000000

じゃあ試しに1を1億回足してみよう。

package main

import (
    "fmt"

    "github.com/shopspring/decimal"
)

func main() {
    x := decimal.NewFromFloat(0)
    y, _ := decimal.NewFromString("1.0")

    for i := 0; i < 100000000; i++ {
        x = x.Add(y)
    }
    fmt.Printf("x = %s\n", x.StringFixed(20))
}

実行結果はこうなる。

$ go run big4b.go
x = 100000000.00000000000000000000

結構な時間がかかった。でも「情報落ち」もなく綺麗に1億になったようだ。

ブックマーク

参考図書

プログラミング言語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)

float32 は32ビットサイズの浮動小数点数型で，符号部1ビット，指数部8ビット，仮数部23ビット，という内訳になっている（仮数部は仮数の小数点以下を表す）。つまり有効桁数が24ビット（10進数で約7桁）しかない。したがって今回のような「1づつ加算する動作を繰り返す」処理では16,777,216（=0xffffff+1）以降は「情報落ち」が発生する。ちなみに float64 は64ビットサイズで仮数部は52ビットあり，10進数にして約15桁の有効桁数になる。 ↩︎
“d := 0.0” と記述した場合，変数 d は float64 として宣言・初期化される。厳密には定数 “0.0” は，いったん「型付けなし」の浮動小数点数として評価された後，変数宣言時に float64 に暗黙的に変換される。 Go 言語におけるこの定数の機能は何かと便利なので覚えておくとよいだろう。 ↩︎
このような結果になるのは float32/float64 の浮動小数点数型の内部表現が2進数になっているため。たとえば 0.1 を2進数で表すと「0.000110011…」と循環しキリのいい値にならない。このため 0.1 を加算していくと「丸め誤差」が蓄積していくのである。 ↩︎

Go 言語における「オブジェクト」

2015-12-15T12:19:58+00:00

Go 言語がいわゆる「オブジェクト指向言語」と言えるかどうかについては色々とあるようだが，オブジェクト指向プログラミングを助けるための仕掛けはいくつか存在する。今回はその中の type キーワードを中心に解説していく。

なお，今回のソースコードは “A Tour of Go” のものをかなり流用しているため取り扱いに注意。 Go 言語の公式ドキュメントは CC License の by 3.0，ソースコードは BSD license で提供されている。

Go 言語の基本型

今さらだけど， Go 言語の基本型（basic type）は以下の通り。

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
uintptr
byte
rune
float32, float64
complex64, complex128

このうち byte は uint8 の別名で rune¹ は int32 の別名である。また int, uint, uintptr のサイズはプラットフォーム依存になっている。 string は不変（immutable）な値で，その実体は byte 配列である。基本型は組み込み型であり，振る舞いを追加・変更することはできない。

さらにこれらの基本型を集約した構造体 struct を定義できる。

package main

import "fmt"

func main() {
    vertex := struct {
        X int
        Y int
    }{X: 1, Y: 2}
    fmt.Println(vertex)
}

ちなみに構造体のフィールド（field）には構造体を含めることができ，入れ子構造にすることもできる。

この他に配列（slice² を含む）や連想配列（map）あるいは関数値（function value）といったものもあるが，今回は踏み込まない。

型に名前を付ける

全ての型には type キーワードを使った宣言（type declaration）により名前を付けることができる。例えば先ほどのコードは

package main

import "fmt"

type Vertex struct {
    X int
    Y int
}

func main() {
    vertex := Vertex{X: 1, Y: 2}
    fmt.Println(vertex)
}

と書き直すことができる。

type 宣言が使えるのは構造体だけではない。上述の基本型も type 宣言を使って型を再定義できる。

たとえば，2つの時点間の時間を表す time.Duration は以下のように定義されている。

type Duration int64

また，配列なども型として再定義できる。

type Msgs []string

type 宣言を使って型に名前を付ける利点は3つある。

名前を付けることでコードの可読性を上げる（オブジェクト指向設計では名前がとても重要）
再利用性の向上（特に構造体の場合）
型に関数を関連付けることができる。

type 宣言による名付けは単なる別名定義ではないということだ³。

型に関数を関連付ける

型に関数を関連付けるには以下のように記述する。

func (v Vertex) String() string {
    return fmt.Sprint("X =", v.X, ", Y =", v.Y)
}

(v Vertex) の部分はメソッド・レシーバ（method receiver）と呼ばれ，これが型と関数を関連付ける役割を果たす。内部処理としては

func Vertex.String(v Vertex) string {
    return fmt.Sprint("X =", v.X, ", Y =", v.Y)
}

と等価である⁴。関数の呼び出し側は

package main

import "fmt"

type Vertex struct {
    X int
    Y int
}

func (v Vertex) String() string {
    return fmt.Sprint("X = ", v.X, ", Y = ", v.Y)
}

func main() {
    vertex := Vertex{X: 1, Y: 2}
    fmt.Println(vertex.String())
}

のようにインスタンスと関数をピリオドで連結して記述する⁵。

構造体そのものには関数を付与できない⁶。たとえば

package main

import "fmt"

func (v struct{ X, Y int }) String() string {
    return fmt.Sprint("X =", v.X, ", Y =", v.Y)
}

func main() {
    var vertex = struct {
        X int
        Y int
    }{X: 1, Y: 2}
    fmt.Println(vertex.String())
}

などと書いても，コンパイル時に

invalid receiver type struct { X int; Y int } (struct { X int; Y int } is an unnamed type)

と怒られる。 type 宣言によって型に名前が付けられていることが重要なのだ。

Go 言語には class キーワードはないが， type 宣言を使うことで，名前と属性と操作を持つクラスを記述することができる⁷。

汎化・特化と処理の委譲

オブジェクト指向設計においてクラス間の関係は大きく2つある。

汎化・特化⁸（継承または is-a 関係）
関連⁹（包含または has-a 関係）

このうち関連についてはこれまで説明した方法で実現できるが，汎化・特化は表現できない。そこで以下の機能を使って汎化・特化を実現する。

振る舞いのみを定義した型

interface を使うと振る舞いのみを定義した汎化クラスを表現することができる。

interface で定義された型で最もよく目にするのは error だろう。 error は以下のように定義できる¹⁰。

type error interface {
    Error() string
}

定義が示すように error は「string 型を返す Error() 関数」のみが定義されている。逆に言うと「string 型を返す Error() 関数」を持つ全ての型は error の一種（つまり is-a 関係）であると見なすことができる¹¹。

たとえば

package os

// PathError records an error and the operation and file path that caused it.
type PathError struct {
    Op   string
    Path string
    Err  error
}

func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() }

と定義される os.PathError は error の一種である。

interface も type 宣言で名前を付けることができ，他の型と同じように扱うことができる。さらに interface で定義した型は振る舞いのみで具体的な実装を含まないため，多態性を持たせた記述が可能になる¹²。

将来バージョンで総称型（generics）がサポートされるかも。

現行版の Go 言語ではいわゆる「総称型」はサポートされていないが，将来バージョンで導入される可能性がある。

次期 Go 言語で導入される（かもしれない）総称型について予習する

型の埋め込み

もうひとつの汎化・特化の機能が型の埋め込み（embedding）である。構造体や interface には別の型を埋め込むことができる。

たとえば io.ReadWriter は以下のように Reader および Writer を埋め込んでいる。（このときの Reader および Writer を「埋め込みインタフェース（embedding interface）」と呼ぶ）

package io

// Implementations must not retain p.
type Reader interface {
    Read(p []byte) (n int, err error)
}

// Implementations must not retain p.
type Writer interface {
    Write(p []byte) (n int, err error)
}

// ReadWriter is the interface that groups the basic Read and Write methods.
type ReadWriter interface {
    Reader
    Writer
}

これによって ReadWriter は Read() および Write() を自身の振る舞いのように扱うことができる。この場合も ReadWriter は Reader および Writer の一種であると見なすことができる。

同様に bufio.ReadWriter についても

package bufio

// ReadWriter stores pointers to a Reader and a Writer.
// It implements io.ReadWriter.
type ReadWriter struct {
    *Reader
    *Writer
}

// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
    return &ReadWriter{r, w}
}

と実装されていて， bufio の Reader および Writer を埋め込み，これらの型の一種として実装されている。このときの Reader および Writer を「埋め込みフィールド（embedded field）」または「匿名フィールド（anonymous field）」と呼ぶ。 bufio.ReadWriter は io.ReadWriter の一種として機能している点にも注目してほしい。

関数のオーバーライドと処理の委譲

では，今まで述べたことを使って以下のコードを書いてみる。

package main

import "fmt"

type ErrorInfo interface {
    error
    Errno() int
}

type ErrorInfo1 struct{}

func (err *ErrorInfo1) Error() string {
    return fmt.Sprint("Error Information: ", err.Errno())
}

func (err *ErrorInfo1) Errno() int {
    return 1
}

func Action() error {
    err := &ErrorInfo1{}
    return err
}

func main() {
    if err := Action(); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Normal End")
}

error の拡張として ErrorInfo interface を定義する。 ErrorInfo interface では error を埋め込み，さらに Errno() 関数を追加定義している。更に ErrorInfo interface に適合するクラスとして ErrorInfo1 型を作った。このコードの実行すると “Error Information: 1” が出力される。

ErrorInfo interface

次に ErrorInfo1 のバリエーションとして ErrorInfo2 を追加してみよう。

package main

import "fmt"

type ErrorInfo interface {
    error
    Errno() int
}

type ErrorInfo1 struct{}

func (err *ErrorInfo1) Error() string {
    return fmt.Sprint("Error Information: ", err.Errno())
}

func (err *ErrorInfo1) Errno() int {
    return 1
}

type ErrorInfo2 struct {
    ErrorInfo1
}

func (err *ErrorInfo2) Errno() int {
    return 2
}

func Action() error {
    err := &ErrorInfo2{}
    return err
}

func main() {
    if err := Action(); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Normal End")
}

ErrorInfo2 では Error() 関数は ErrorInfo1 のものをそのまま使い回したいが Errno() 関数では異なる値を出力したい，と考えた。そこで Errno() 関数をオーバライドしようと考えた。図で書くと以下のような構成を期待したわけだ。

Override ?

しかし実際には，期待した “Error Information: 2” ではなく，前回と同じ “Error Information: 1” が出力される。

上のコードでは ErrorInfo2 と直接関連付けられた Error() がないため ErrorInfo1 の Error() が呼ばれるが，その関数の中で呼ばれる Errno() は ErrorInfo2 と関連付けられた関数ではなく ErrorInfo1 と関連付けられた関数になる。

delegation

これは Go 言語では埋め込みフィールドの関数呼び出しが「委譲」として機能しているためである。たとえば C++ 言語では virtual 修飾子を付与して仮想関数化することで意図的にオーバーライドできるが¹³， Go 言語ではこのような仕掛けがないため¹⁴，呼ばれた関数は常に委譲として機能する¹⁵。

上の例はクラス構成からして明らかにダメダメなのだが，今回のポイントはサブクラスである ErrorInfo2 から Errno() 関数を上書きすることでスーパークラス ErrorInfo1 の Error() 関数の処理を書き換えようとした点にある。継承¹⁶ の実装で一番よくあるミスがこの「カプセル化の破れ」で， Go 言語の場合は敢えて移譲を強制することでこの手の不具合が発生するのを回避しようとしているように見える。

他の言語では明示的に委譲を実装しようとすると冗長な記述になることが多いが， Go 言語の場合は埋め込みを使うことでシンプルな記述で委譲を実装できる点がメリットと言える。

ブックマーク

Big Sky :: Go言語でインタフェースの変更がそれ程問題にならない理由
オブジェクト指向言語としてGolangをやろうとするとハマること - Qiita
- オブジェクト指向言語としてGolangをやろうとするとハマる点を整理してみる - Qiita
Go言語に継承は無いんですか【golang】 - DRYな備忘録
Go言語でジェネリクスっぽいことがしたいでござる【generics】【golang】 - DRYな備忘録
Go 言語の値レシーバとポインタレシーバ | Step by Step
埋込みとインタフェース #golang - Qiita
Goにatexitやグローバルなデストラクタがない理由 - Qiita
Python と Ruby と typing - methaneのブログ : interface を使った汎化・特化の関係は duck typing ではなく「構造的部分型（structural subtyping）」と言うのが正しいらしい

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)

rune は Unicode 文字の符号点（code point）を示す型で文字そのものを表現する。 string と rune の関係については「String と Rune」を参照のこと。 ↩︎
配列と slice の関係については「配列と Slice」で紹介している。 ↩︎
型の別名定義はバージョン 1.9 から導入された。詳しくは「Go 1.9 と Type Alias」を参照のこと ↩︎
Go 言語の関数呼び出しにおいて引数の渡し方は基本的に「値渡し」である。詳しくは「関数とポインタ」を参照のこと。 ↩︎
ちなみに fmt.Print などでは引数の型が String() を持っていることを期待し，この関数の出力結果をデフォルト書式にしている。したがって fmt.Println(vertex) と書いても同じ結果になる。 ↩︎
他にも基本型や他パッケージで定義されている型に関数を追加することはできない。当たり前だけど。 ↩︎
クラスは名前と属性と操作の3つの要素で構成されている。名前は他クラスと識別できるものを1個。属性と操作は0個以上存在する。 Go 言語では空のフィールドの struct を定義することにより0個の属性を持つクラスを構成できる。 ↩︎
言わずもがなだが，サブクラスから見たスーパークラスが「汎化」でその逆が「特化」である。 ↩︎
関連は更に集約と複合に分類できるが今回は踏み込まない。 ↩︎
error は組み込み型なので，実際にこのような定義が標準パッケージにあるわけではない。 error について詳しくは「エラー・ハンドリングについて」を参照のこと。 ↩︎
Go 言語では Java の implement のような interface クラスからの継承を明示するキーワードはない。記述された振る舞いからクラス関係を決定する方法を「構造的部分型（structural subtyping）」と呼ぶ。構造的部分型のメリットのひとつは多重継承で発生する様々な問題（名前の衝突や菱形継承など）を気にする必要がない点である。 ↩︎
たとえば interface{} と記述すればあらゆる型を含むことになる。これを利用して fmt.Print は func Print(a ...interface{}) (n int, err error) { ... } と定義されている。 ↩︎
逆に Java では関数は常に仮想関数として機能しオーバーライドされる可能性がある。これを抑止するためには final 修飾子を付加する。 ↩︎
Go 言語的には埋め込みフィールドはフィールドのバリエーションのひとつにすぎないため，動作も通常のフィールドが持つ関数を呼び出した場合と変わらない。そういう意味では構造体への埋め込みは，見かけ上は「is-a 関係」でも，実質的には「has-a 関係」に近いと言えるかもしれない。 ↩︎
複数の型を埋め込んでいる場合，埋め込みフィールド間で名前が衝突しているフィールドや関数を使おうとするとコンパイルエラーになる。この場合は err.ErrorInfo1.Error() のように型を明示して回避できる。 ↩︎
ここで言う継承は設計時の「汎化・特化」のことではなく，言語機能などを使った実装上の継承のこと。 ↩︎