mirror of
https://github.com/golang/go
synced 2024-11-14 23:20:27 -07:00
c2b87ce007
I removed the broken function comparison example and fixed a code highlighting regexp. R=golang-dev, adg CC=golang-dev https://golang.org/cl/5501078
106 lines
4.3 KiB
XML
106 lines
4.3 KiB
XML
<codewalk title="First-Class Functions in Go">
|
|
|
|
<step title="Introduction" src="doc/codewalk/pig.go">
|
|
Go supports first class functions, higher-order functions, user-defined
|
|
function types, function literals, closures, and multiple return values.
|
|
<br/><br/>
|
|
|
|
This rich feature set supports a functional programming style in a strongly
|
|
typed language.
|
|
<br/><br/>
|
|
|
|
In this codewalk we will look at a simple program that simulates a dice game
|
|
called <a href="http://en.wikipedia.org/wiki/Pig_(dice)">Pig</a> and evaluates
|
|
basic strategies.
|
|
</step>
|
|
|
|
<step title="Game overview" src="doc/codewalk/pig.go:/\/\/ A score/,/thisTurn int\n}/">
|
|
Pig is a two-player game played with a 6-sided die. Each turn, you may roll or stay.
|
|
<ul>
|
|
<li> If you roll a 1, you lose all points for your turn and play passes to
|
|
your opponent. Any other roll adds its value to your turn score. </li>
|
|
<li> If you stay, your turn score is added to your total score, and play passes
|
|
to your opponent. </li>
|
|
</ul>
|
|
|
|
The first person to reach 100 total points wins.
|
|
<br/><br/>
|
|
|
|
The <code>score</code> type stores the scores of the current and opposing
|
|
players, in addition to the points accumulated during the current turn.
|
|
</step>
|
|
|
|
<step title="User-defined function types" src="doc/codewalk/pig.go:/\/\/ An action/,/bool\)/">
|
|
In Go, functions can be passed around just like any other value. A function's
|
|
type signature describes the types of its arguments and return values.
|
|
<br/><br/>
|
|
|
|
The <code>action</code> type is a function that takes a <code>score</code>
|
|
and returns the resulting <code>score</code> and whether the current turn is
|
|
over.
|
|
<br/><br/>
|
|
|
|
If the turn is over, the <code>player</code> and <code>opponent</code> fields
|
|
in the resulting <code>score</code> should be swapped, as it is now the other player's
|
|
turn.
|
|
</step>
|
|
|
|
<step title="Multiple return values" src="doc/codewalk/pig.go:/\/\/ roll returns/,/true\n}/">
|
|
Go functions can return multiple values.
|
|
<br/><br/>
|
|
|
|
The functions <code>roll</code> and <code>stay</code> each return a pair of
|
|
values. They also match the <code>action</code> type signature. These
|
|
<code>action</code> functions define the rules of Pig.
|
|
</step>
|
|
|
|
<step title="Higher-order functions" src="doc/codewalk/pig.go:/\/\/ A strategy/,/action\n/">
|
|
A function can use other functions as arguments and return values.
|
|
<br/><br/>
|
|
|
|
A <code>strategy</code> is a function that takes a <code>score</code> as input
|
|
and returns an <code>action</code> to perform. <br/>
|
|
(Remember, an <code>action</code> is itself a function.)
|
|
</step>
|
|
|
|
<step title="Function literals and closures" src="doc/codewalk/pig.go:/return func/,/return roll\n\t}/">
|
|
Anonymous functions can be declared in Go, as in this example. Function
|
|
literals are closures: they inherit the scope of the function in which they
|
|
are declared.
|
|
<br/><br/>
|
|
|
|
One basic strategy in Pig is to continue rolling until you have accumulated at
|
|
least k points in a turn, and then stay. The argument <code>k</code> is
|
|
enclosed by this function literal, which matches the <code>strategy</code> type
|
|
signature.
|
|
</step>
|
|
|
|
<step title="Simulating games" src="doc/codewalk/pig.go:/\/\/ play/,/currentPlayer\n}/">
|
|
We simulate a game of Pig by calling an <code>action</code> to update the
|
|
<code>score</code> until one player reaches 100 points. Each
|
|
<code>action</code> is selected by calling the <code>strategy</code> function
|
|
associated with the current player.
|
|
</step>
|
|
|
|
<step title="Simulating a tournament" src="doc/codewalk/pig.go:/\/\/ roundRobin/,/gamesPerStrategy\n}/">
|
|
The <code>roundRobin</code> function simulates a tournament and tallies wins.
|
|
Each strategy plays each other strategy <code>gamesPerSeries</code> times.
|
|
</step>
|
|
|
|
<step title="Variadic function declarations" src="doc/codewalk/pig.go:/\/\/ ratioS/,/string {/">
|
|
Variadic functions like <code>ratioString</code> take a variable number of
|
|
arguments. These arguments are available as a slice inside the function.
|
|
</step>
|
|
|
|
<step title="Simulation results" src="doc/codewalk/pig.go:/func main/,/\n}/">
|
|
The <code>main</code> function defines 100 basic strategies, simulates a round
|
|
robin tournament, and then prints the win/loss record of each strategy.
|
|
<br/><br/>
|
|
|
|
Among these strategies, staying at 25 is best, but the <a
|
|
href="http://www.google.com/search?q=optimal+play+pig">optimal strategy for
|
|
Pig</a> is much more complex.
|
|
</step>
|
|
|
|
</codewalk>
|