個人的Go雑感&メモ

GoogleがGoという新しいプログラミング言語を出したようで。早速、インストールして軽くドキュメントを流し読みしてみました。

英語なんて読みたくないよ、という人もいるかもしれないし、誰かの役に立つかもしれないので自分用メモおいときます。完全に自分用なんである程度他の言語の知識がある人向けな上、ざっくり流し読みなんで間違ってるかも。

どんな言語？

  • ネイティブコードを吐く、コンパイル型。
  • 速度はCレベル。
  • GC搭載。ポインタはあるけど、ポインタ演算はできません。
  • 各種アーキに最適化された、それぞれのコンパイラセットを持ちます。例：
    • 6g, 6l : amd64
    • 8g, 8l : i386
  • linux, mac, naclに対応。
  • 動的型言語と静的型言語のおいしいとこどり。
  • concurrent処理が組み込まれてます。

個人的雑感

  • こんな言語設計思想かなあと感じたり
    • とにかく、シンプルな言語に。
      • C++の複雑な部分などはできるだけはずしているような。
        • いわゆるクラスベースのオブジェクト指向はない。
          • 継承はない。
          • あるのはフラットなインタフェース空間のみ。
        • 例外もない。
    • 低レイヤからは離れすぎたくない。
    • concurrentを言語的にサポートしたい。
  • 以下の言語からの影響を感じたり
    • 言語コアはC。
    • C++はパッケージの書き方、記法に影響がみられる。
    • 命名規則や記法にPythonの影響がみられる。
    • concurrentな部分はErlangから影響をうけている。

言語仕様

自分なりに簡単にまとめて見ます。

変数への代入

下へ行くほど省略形。varもあるからconstもあるでよ。

 code
  1. var s string = "";
  2. var s = "";
  3. s := "";
  4.  

オブジェクト構造

値扱いの型と参照型があります。

  • 値扱い : 代入、関数への私はコピーとなる。配列もまるごとコピーされる。
    • 各種数値 : int, floatといったプラットフォームごとにサイズがきまる型とint32のようにサイズ固定の型。
    • string : 不変、UTF8、ただのバイト配列
    • 配列
    • struct : ユーザ定義型
    • などなど
  • 参照 : 3つのみ
    • map : 辞書
    • slice : 明示的なサイズを持たない、配列のようなもの
    • channel : concurrentで使う

値扱い型のアロケート方法 : new -> T*を返す

 code
  1. var t *T = new(T);
  2.  

参照型のアロケート方法 : make -> Tを返す

 code
  1. m := make(map[string]int);
  2. // これはダメ
  3. var m map[string]int;
  4.  

配列とスライス

  • 配列は「値」。でユーザがメモリ構造などを読める。スライスはコンパイラがよしなに確保する、参照型。

例えばint型配列のポインタを受け取る場合。

標準配列(&がいる)

 code
  1. s := sum(&[3]int{1,2,3});
  2. s := sum(&[...]int{1,2,3});
  3.  

スライス

 code
  1. s := sum([]int{1,2,3});
  2.  

辞書型

 code
  1. timeZone := map[string]int{
  2.   "UTC": 0*60*60,
  3.   "EST": -5*60*60,
  4.   "CST": -6*60*60,
  5.   "MST": -7*60*60,
  6.   "PST": -8*60*60,
  7. }
  8.  
  9. seconds, ok = timeZone[tz]
  10. //値がなければokはfalse
  11. if seconds, ok := timeZone[tz]; ok {
  12.     return seconds
  13. }
  14. //消す場合
  15. timeZone["UTC"] = 0, false;
  16.  

パッケージ、制御構造、型定義、関数とメソッド、インタフェース

命名規則に特徴があります。大文字始まり以外は外部から見えないが原則。単なる命名規則ではなく、そういう仕様。

パッケージ

パッケージ文でファイルの先頭に書きます。これが基本的な単位となります。

 code
  1. package file
  2.  
制御構造

特徴は

  • ()がいらない。
  • ifやswitchなどの条件部に複数の文がかける
  • ループはforのみ(whileやdoはない)
  • switchが強力に(内容的にif-else if-elseチェイン)
  • concurrent用にselectがある

という点。かと。

ifの例

 code
  1. if i % prime != 0 {
  2.     fmt.Printf("%d", i);
  3. }
  4.  

switchの例

 code
  1. switch nr, er := f.Read(&buf); true {
  2.            case nr < 0:
  3.                fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", f.String(), er.String());
  4.                os.Exit(1);
  5.            case nr == 0: // EOF
  6.                return;
  7.            case nr > 0:
  8.                if nw, ew := file.Stdout.Write(buf[0:nr]); nw != nr {
  9.                    fmt.Fprintf(os.Stderr, "cat: error writing from %s: %s\n", f.String(), ew.String());
  10.                }
  11. }
  12.  

caseに条件式がかける。breakは自動でされる。

型定義

type,structキーワードを組み合わせる。メンバにメソッドは含みません。

 code
  1. type File struct {
  2.     fd int; // file descriptor number
  3.     name string; // file name at Open time
  4. }
  5.  

メンバ名が小文字なので、パッケージ外からは見えません。

関数とメソッド
  • 両方ともfuncキーワードで定義。
  • 違いはレシーバを指定するか否か。 レシーバを明示的に書くところはPythonっぽい。
  • 多値が返せる。

この多値がかえせる、というのがGoでは非常に重要な意味をもっています。

関数定義: 多値を返しています。大文字始まりなので、外部に公開されます。

 code
  1. func Open(name string, mode int, perm int) (file *File, err os.Error) {
  2.      r, e := syscall.Open(name, mode, perm);
  3.      if e != 0 {
  4.          err = os.Errno(e);
  5.      }
  6.      return newFile(r, name), err
  7. }
  8.  

返す型に(file *File, err os.Error)と変数名がついてますね。これをつけておけばreturn;ってかくだけでその名前の変数を返してくれます。

 code
  1. func Open(name string, mode int, perm int) (file *File, err os.Error) {
  2.      r, e := syscall.Open(name, mode, perm);
  3.      if e != 0 {
  4.          err = os.Errno(e);
  5.      }
  6.      file = newFile(r, name)
  7.      return;
  8. }
  9.  

こんな風にもかけるってことです。おそらく、エラー処理が絡む場合とかこっちのほうが書きやすかったりするんじゃないですかね。

クロージャにもなります。いわゆる関数ポインタをとるようなところで、関数がそのままかけて外部変数も見えます。

 code
  1. startServer(func(a, b int) int { return a + b });
  2.  

メソッド定義。(file *File)がレシーバの指定。

 code
  1. func (file *File) Close() os.Error {
  2.     if file == nil {
  3.         return os.EINVAL
  4.     }
  5.     e := syscall.Close(file.fd);
  6.     file.fd = -1; // so it can't be closed again
  7.     if e != 0 {
  8.         return os.Errno(e);
  9.     }
  10.     return nil
  11. }
  12.  

メソッド定義がstructでの型定義時ではないことに注目。つまり組み込み型などに対してもあとからメソッドを作成できるのです。こんな感じ。

 code
  1. type IntArray []int
  2. func (p IntArray) Len() int { return len(p); }
  3.  
インタフェース

これ重要。Goはいわゆるクラスがないので、継承などもなくインタフェースによるダックタイピングでそれらを片付けます。 interfaceキーワードで定義。

 code
  1. type reader interface {
  2.      Read(b []byte) (ret int, err os.Error);
  3.      String() string;
  4. }
  5.  

このように、ReadとStringが定義されていればそれはreaderなんだ、と考えます(ダックタイピング)。

実行時、動的にインタフェースが実装されているかも検査できます。

 code
  1. s, ok := v.(Stringer);
  2.  

vがStringerインタフェースを満たしていれば

  • sにStringerオブジェクトとしてのv
  • okにtrueが

がかえってきます。

Concurrency

concurrentプログラミングはGoの大きな特徴。CSP(Communicating Sequential Processes)に基づいてます。並行して動く「goroutines」という軽量プロセスが「channel」を介してやりとり。ガードと多重化のためにselect文があります。

channelは単体ではなくchan 受け渡しする型という感じで書きます。以下はチュートリアルのコードまんまです。

 code
  1. func generate(ch chan int) {
  2.     for i := 2; ; i++ {
  3.         ch <- i // Send 'i' to channel 'ch'.
  4.     }
  5. }
  6.  

intを扱うchannelを受け取ってそれにiを送っていきます。

 code
  1. func filter(in, out chan int, prime int) {
  2.     for {
  3.         i := <-in; // Receive value of new variable 'i' from 'in'.
  4.         if i % prime != 0 {
  5.             out <- i // Send 'i' to channel 'out'.
  6.         }
  7.     }
  8. }
  9.  

送られたiが一定の条件を満たしていたら、intを扱うoutというchannelに送ります。

 code
  1. func main() {
  2.     ch := make(chan int); // Create a new channel.
  3.     go generate(ch); // Start generate() as a goroutine.
  4.     for {
  5.         prime := <-ch;
  6.         fmt.Println(prime);
  7.         ch1 := make(chan int);
  8.         go filter(ch, ch1, prime);
  9.         ch = ch1
  10.     }
  11. }
  12.  

channelは参照型なのでmakeで作ります。goで実行します。これは丁寧に書いた感じ。クロージャを使えばもっとシンプル。

 code
  1. func generate() chan int {
  2.     ch := make(chan int);
  3.     go func(){
  4.         for i := 2; ; i++ {
  5.             ch <- i
  6.         }
  7.     }();
  8.     return ch;
  9. }
  10.  
多重化とガード

複数のチャンネルをとりあつかって、それらをガードにより振り分けられます。ErlangやScalaでおなじみの書き方です。

 code
  1. func server(op binOp, service chan *request, quit chan bool) {
  2.     for {
  3.         select {
  4.         case req := <-service:
  5.             go run(op, req); // don't wait for it
  6.         case <-quit:
  7.             return;
  8.         }
  9.     }
  10. }
  11.  

request型のポインタを扱うchannelとbool型を扱うchannelを使って、多重化しています。quitチャンネルに値が送られてくるまでは、送られてきたものから良しなに処理してくれる、という感じですね。

というわけで

なぐり書きしたメモでした。変なことかいてたらすみません。まぁこんな感じな言語かなあ、という程度で。

繰り替えしになりますが、C言語を元にシンプルに保ちながらconcurrentプログラミングしやすくしてます、って感じですね。完全にダックタイピングベースで多値を多様するスタイルはおもしろいですね。なんとなく見た目がキモく感じるのは私の気のせいでしょう。

というか数ヶ月もブログ放置してたのかー。コード書いてないわけじゃないんですけど、たいしたもんかいてないんですよね。割合的には8割がたCかな。月一くらいはブログ書いていきたいなあ・・・

01.06.10/12am
Posted at:
11.11.09/08pm
Tags:
Comments:
0
Permalink

About

Author:yuin(http://inforno.net/)

文学部文化学科卒という生粋の文系趣味プログラマ。

主にRuby、Javascript、PHP、JAVA,Python,C,Scala,Schemeなどを使っています。今はPythonな感じかもしれない。今後作曲活動なども復活するかもしれない。

Links

Pages

Recently

Tags

DHT1 SF1 activesupport1 api4 binary3 blog1 book1 cltc1 compiler1 craftlaunch2 cui1 development9 drecom1 electronics1 emulator6 erlang1 essay10 fckeditor1 feed1 framework1 gae3 go1 gui2 javascript14 job4 kademlia1 language2 library14 life5 lingr1 linux1 nes5 network1 nicovideo1 nlp1 ocaml1 p2p1 parser6 programing2 prototype_js7 python40 python30001 rayphe1 ruby5 rubyonrails2 scala6 scheme1 scrap1 scriptaculous1 sexp1 tasktools1 template3 text3 tk1 typo2 vim2 webpy2 windows4 wordpress2 xrea2 yahoo4

Monthly Archives