コードウォーク - Goにおけるファーストクラス関数（First-Class Functions in Go） - 《Goプログラミング言語

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
    "fmt"
    "math/rand"
)
const (
    win            = 100 // The winning score in a game of Pig
    gamesPerSeries = 10  // The number of games per series to simulate
)
// A score includes scores accumulated in previous turns for each player,
// as well as the points scored by the current player in this turn.
type score struct {
    player, opponent, thisTurn int
}
// An action transitions stochastically to a resulting score.
type action func(current score) (result score, turnIsOver bool)
// roll returns the (result, turnIsOver) outcome of simulating a die roll.
// If the roll value is 1, then thisTurn score is abandoned, and the players'
// roles swap.  Otherwise, the roll value is added to thisTurn.
func roll(s score) (score, bool) {
    outcome := rand.Intn(6) + 1 // A random int in [1, 6]
    if outcome == 1 {
        return score{s.opponent, s.player, 0}, true
    }
    return score{s.player, s.opponent, outcome + s.thisTurn}, false
}
// stay returns the (result, turnIsOver) outcome of staying.
// thisTurn score is added to the player's score, and the players' roles swap.
func stay(s score) (score, bool) {
    return score{s.opponent, s.player + s.thisTurn, 0}, true
}
// A strategy chooses an action for any given score.
type strategy func(score) action
// stayAtK returns a strategy that rolls until thisTurn is at least k, then stays.
func stayAtK(k int) strategy {
    return func(s score) action {
        if s.thisTurn >= k {
            return stay
        }
        return roll
    }
}
// play simulates a Pig game and returns the winner (0 or 1).
func play(strategy0, strategy1 strategy) int {
    strategies := []strategy{strategy0, strategy1}
    var s score
    var turnIsOver bool
    currentPlayer := rand.Intn(2) // Randomly decide who plays first
    for s.player+s.thisTurn < win {
        action := strategies[currentPlayer](s)
        s, turnIsOver = action(s)
        if turnIsOver {
            currentPlayer = (currentPlayer + 1) % 2
        }
    }
    return currentPlayer
}
// roundRobin simulates a series of games between every pair of strategies.
func roundRobin(strategies []strategy) ([]int, int) {
    wins := make([]int, len(strategies))
    for i := 0; i < len(strategies); i++ {
        for j := i + 1; j < len(strategies); j++ {
            for k := 0; k < gamesPerSeries; k++ {
            winner := play(strategies[i], strategies[j])
            if winner == 0 {
            wins[i]++
            } else {
            wins[j]++
            }
            }
        }
    }
    gamesPerStrategy := gamesPerSeries * (len(strategies) - 1) // no self play
    return wins, gamesPerStrategy
}
// ratioString takes a list of integer values and returns a string that lists
// each value and its percentage of the sum of all values.
// e.g., ratios(1, 2, 3) = "1/6 (16.7%), 2/6 (33.3%), 3/6 (50.0%)"
func ratioString(vals ...int) string {
    total := 0
    for _, val := range vals {
        total += val
    }
    s := ""
    for _, val := range vals {
        if s != "" {
            s += ", "
        }
        pct := 100 * float64(val) / float64(total)
        s += fmt.Sprintf("%d/%d (%0.1f%%)", val, total, pct)
    }
    return s
}
func main() {
    strategies := make([]strategy, win)
    for k := range strategies {
        strategies[k] = stayAtK(k + 1)
    }
    wins, games := roundRobin(strategies)
    for k := range strategies {
        fmt.Printf("Wins, losses staying at k =% 4d: %s\n",
            k+1, ratioString(wins[k], games-wins[k]))
    }
}

はじめに

Goは、第一級関数、高階関数、ユーザー定義関数型、関数リテラル、クロージャ、および複数の戻り値をサポートしています。

この豊富な機能セットは、強く型付けされた言語における関数型プログラミングスタイルをサポートします。

このコードウォークでは、サイコロゲーム「Pig」をシミュレートするシンプルなプログラムを見て、基本的な戦略を評価します。

doc/codewalk/pig.go

ゲームの概要

Pigは、6面のサイコロを使った2人用のゲームです。各ターンで、振るか留まるかを選択できます。

1が出た場合、そのターンのポイントはすべて失われ、プレイは相手に移ります。他のいずれかの出目は、その値をターンスコアに加えます。
留まる場合、ターンスコアは合計スコアに加算され、プレイは相手に移ります。
最初に合計100ポイントに達した人が勝ちです。

score型は、現在のプレイヤーと対戦相手のスコアに加え、現在のターン中に蓄積されたポイントを保存します。

doc/codewalk/pig.go:17,21

ユーザー定義関数型

Goでは、関数は他の値と同様に渡すことができます。関数の型シグネチャは、その引数と戻り値の型を説明します。

action型は、scoreを引数に取り、結果のscoreと現在のターンが終了したかどうかを返す関数です。

ターンが終了した場合、結果のscore内のplayerとopponentフィールドは入れ替える必要があります。なぜなら、今は他のプレイヤーのターンだからです。

doc/codewalk/pig.go:23,24

複数の戻り値

Goの関数は複数の値を返すことができます。

関数rollとstayはそれぞれ一対の値を返します。また、action型シグネチャに一致します。これらのaction関数は、Pigのルールを定義します。

doc/codewalk/pig.go:26,41

高階関数

関数は他の関数を引数として使用したり、戻り値として返したりできます。

strategyは、scoreを入力として受け取り、実行するactionを返す関数です。

（覚えておいてください、actionはそれ自体が関数です。）

doc/codewalk/pig.go:43,44

関数リテラルとクロージャ

Goでは、匿名関数を宣言できます。この例のように。関数リテラルはクロージャです：それらは宣言された関数のスコープを継承します。

Pigにおける基本的な戦略の1つは、ターン中に少なくともkポイントを蓄積するまで振り続け、その後留まることです。引数kは、この関数リテラルによって囲まれており、strategy型シグネチャに一致します。

doc/codewalk/pig.go:48,53

ゲームのシミュレーション

actionを呼び出してscoreを更新することで、Pigのゲームをシミュレートします。1人のプレイヤーが100ポイントに達するまで、各actionは現在のプレイヤーに関連付けられたstrategy関数を呼び出すことで選択されます。

doc/codewalk/pig.go:56,70

トーナメントのシミュレーション

roundRobin関数はトーナメントをシミュレートし、勝利を集計します。各戦略は、他の各戦略とgamesPerSeries回対戦します。

doc/codewalk/pig.go:72,89

可変引数関数の宣言

ratioStringのような可変引数関数は、可変数の引数を取ります。これらの引数は、関数内でスライスとして利用可能です。

doc/codewalk/pig.go:91,94

シミュレーション結果

main関数は100の基本戦略を定義し、ラウンドロビン方式のトーナメントをシミュレートし、その後各戦略の勝敗記録を印刷します。

これらの戦略の中で、25で留まることが最も良いですが、Pigの最適戦略ははるかに複雑です。

doc/codewalk/pig.go:110,121

•