Difference between revisions of "Learning Haskell with Chess"

From HaskellWiki
Jump to navigation Jump to search
m (Learning Haskell With Chess moved to Learning Haskell with Chess)
(Wikifying markup)
Line 1: Line 1:
−
This page is about learning Haskell using the board game Chess as a running example. The complete code can be found at [http://www.steffen-mazanek.de/dateien/projekte/hsChess.zip].
 +
This page is about learning Haskell using the board game Chess as a running example. The complete code can be found at http://www.steffen-mazanek.de/dateien/projekte/hsChess.zip.
   
−
<h1>Exercise 1 - Data Types</h1>
 +
==Exercise 1 - data types==
   
−
<h2>Learning Targets</h2>
 +
===Learning targets===
  ⚫
*recapitulate Haskell types (keywords type and data, product and sum types)
−
<ul>
  
  ⚫
*Helium: define equality functions (pattern matching)
⚫
<li>recapitulate Haskell types (keywords type and data, product and sum types)</li>
  
  ⚫
*pretty printing
⚫
<li>Helium: define equality functions (pattern matching)</li>
  
⚫
<li>pretty printing</li>
  
−
</ul>
  
   
−
<h2>Tasks</h2>
 +
===Tasks===
  ⚫
*Define data types that represent boards (<hask>Board</hask>), squares (<hask>Square</hask>), positions (<hask>Pos</hask>), pieces (<hask>Piece</hask>) and game states (<hask>State</hask>).
−
<ul>
  
  ⚫
*Helium: Implement suited eq-functions.
⚫
<li>Define data types that represent boards (Board), squares (Square), positions (Pos), pieces (Piece) and game states (State).</li>
  
  ⚫
*Implement a function <hask>prettyBoard::Board->String</hask>, that transforms a board into a clearly arranged string representation (human readable :-)). Support this function with auxiliary functions that pretty print pieces, squares, ...
⚫
<li>Helium: Implement suited eq-functions.</li>
  
  ⚫
*Define the initial board (<hask>initialBoard::Board</hask>), test prettyBoard with initialBoard.
⚫
<li>Implement a function prettyBoard::Board->String, that transforms a board into a clearly arranged string representation (human readable :-)). Support this function with auxiliary functions that pretty print pieces, squares, ...</li>
  
  ⚫
*Implement a simple evaluation function <hask>evalBoard::Board->Int</hask> as the difference of material on board (values: Pawn->1, Knight and Bishop->3, Queen->9, Rook->6, King->"infinity"=1000).
⚫
<li>Define the initial board (initialBoard::Board), test prettyBoard with initialBoard.</li>
  
⚫
<li>Implement a simple evaluation function evalBoard::Board->Int as the difference of material on board (values: Pawn->1, Knight and Bishop->3, Queen->9, Rook->6, King->"infinity"=1000).</li>
  
−
</ul>
  
   
−
<h1>Exercise 2 - Move Generator</h1>
 +
==Exercise 2 - move generator==
−
<h2>Learning Targets</h2>
 +
===Learning targets===
  ⚫
*list comprehension
−
<ul>
  
  ⚫
*stepwise refinement
⚫
<li>list comprehension</li>
  
  +
===Tasks===
⚫
<li>stepwise refinement</li>
  
−
</ul>
  
−
<h2>Tasks</h2>
  
   
−
<h1>Exercise 3 - Gametree Generation and Minimax Algorithm</h1>
 +
==Exercise 3 - gametree generation and minimax algorithm==
−
<h2>Learning Targets</h2>
 +
===Learning targets===
  ⚫
*break code in modules
−
<ul>
  
  ⚫
*complexity
⚫
<li>break code in modules</li>
  
  ⚫
*recursive data structures -> recursive algorithms
⚫
<li>complexity</li>
  
  +
⚫
<li>recursive data structures -> recursive algorithms</li>
  
  +
===Tasks===
−
</ul>
  
  +
*Define a data type that represents a game tree (<hask>GameTree</hask>).
−
<h2>Tasks</h2>
  
  ⚫
*Roughly estimate the number of nodes of the gametree with depth 4.
−
<ul>
  
−
<li>Define a data type that represents a game tree (GameTree).</li>
 +
*Define a function <hask>play::Gametree->Int</hask>, that computes the value of a given game tree using the minimax Algorithm.
  ⚫
*Implement the function <hask>doMove::State->State</hask>, that choses the (best) next state.
⚫
<li>Roughly estimate the number of nodes of the gametree with depth 4.</li>
  
−
<li>Define a function play::Gametree->Int, that computes the value of a given game tree using the minimax Algorithm.</li>
  
⚫
<li>Implement the function doMove::State->State, that choses the (best) next state.</li>
 
−
</ul>
  

Revision as of 16:34, 18 March 2007

This page is about learning Haskell using the board game Chess as a running example. The complete code can be found at http://www.steffen-mazanek.de/dateien/projekte/hsChess.zip.

Exercise 1 - data types

Learning targets

  • recapitulate Haskell types (keywords type and data, product and sum types)
  • Helium: define equality functions (pattern matching)
  • pretty printing

Tasks

  • Define data types that represent boards (Board), squares (Square), positions (Pos), pieces (Piece) and game states (State).
  • Helium: Implement suited eq-functions.
  • Implement a function prettyBoard::Board->String, that transforms a board into a clearly arranged string representation (human readable :-)). Support this function with auxiliary functions that pretty print pieces, squares, ...
  • Define the initial board (initialBoard::Board), test prettyBoard with initialBoard.
  • Implement a simple evaluation function evalBoard::Board->Int as the difference of material on board (values: Pawn->1, Knight and Bishop->3, Queen->9, Rook->6, King->"infinity"=1000).

Exercise 2 - move generator

Learning targets

  • list comprehension
  • stepwise refinement

Tasks

Exercise 3 - gametree generation and minimax algorithm

Learning targets

  • break code in modules
  • complexity
  • recursive data structures -> recursive algorithms

Tasks

  • Define a data type that represents a game tree (GameTree).
  • Roughly estimate the number of nodes of the gametree with depth 4.
  • Define a function play::Gametree->Int, that computes the value of a given game tree using the minimax Algorithm.
  • Implement the function doMove::State->State, that choses the (best) next state.
Retrieved from "https://wiki.haskell.org/index.php?title=Learning_Haskell_with_Chess&oldid=12048"