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

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” が出力される。

次に 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() 関数をオーバライドしようと考えた。図で書くと以下のような構成を期待したわけだ。

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

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

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

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

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() のように型を明示して回避できる。 ↩︎
ここで言う継承は設計時の「汎化・特化」のことではなく，言語機能などを使った実装上の継承のこと。 ↩︎