diff -u a/tictactoe.rs b/tictactoe.rs
--- a/tictactoe.rs  2015-05-19 23:00:25.261881078 +0200
+++ b/tictactoe.rs  2015-05-20 14:46:25.370780762 +0200
@@ -1,16 +1,19 @@
+#![feature(core, rand)]
 extern crate core;
-use std::io;
+use std::io::{self,Write};
 use std::rand;
 use std::rand::distributions::{IndependentSample, Range};

-#[deriving(PartialEq)]
+#[derive(PartialEq, Clone, Copy)]
 enum Field {
    N,
    X,
    O,
 }

-impl core::fmt::Show for Field {
+use Field::{N,X,O};
+
+impl core::fmt::Display for Field {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        write!(f, "{}", match *self {
            N => ' ',
@@ -28,7 +31,7 @@
    }
 }

-fn show(board:&[Field, ..9]) {
+fn show(board:&[Field; 9]) {
    print!("+---+\n");
    print!("|{}{}{}|\n", board[0], board[1], board[2]);
    print!("|{}{}{}|\n", board[3], board[4], board[5]);
@@ -37,20 +40,20 @@
 }

 // Should perhaps be refactored to iterator?
-fn streaks(board:&[Field, ..9], streak_handler:|[Field, ..3]|->()) {
-   for row in range(0u, 3u) {
+fn streaks<F>(board:&[Field; 9], streak_handler:&mut F) where F : FnMut([Field; 3]) {
+   for row in 0..3 {
        streak_handler([board[3*row + 0], board[3*row + 1], board[3*row + 2]]);
    }
-   for col in range(0u, 3u) {
+   for col in 0..3 {
        streak_handler([board[3*0 + col], board[3*1 + col], board[3*2 + col]]);
    }
    streak_handler([board[3*0 + 0], board[3*1 + 1], board[3*2 + 2]]);
    streak_handler([board[3*0 + 2], board[3*1 + 1], board[3*2 + 0]]);
 }

-fn find_winner(board:&[Field, ..9]) -> Field {
-   let mut winner:Field = N;
-   streaks(board, |streak| {
+fn find_winner(board:&[Field; 9]) -> Field {
+   let mut winner = N;
+   streaks(board, &mut |streak:[Field; 3]| {
        if streak[0] != N && streak[0] == streak[1] && streak[1] == streak[2] {
            winner = streak[0];
        }
@@ -58,24 +61,24 @@
    return winner;
 }

-fn free_pos(board:&[Field, ..9], pos_handler:|uint|->()) {
-   for pos in range(0u, 9u) {
+fn free_pos<F>(board:&[Field; 9], pos_handler:&mut F) where F : FnMut(usize) {
+   for pos in 0..9 {
        if board[pos] == N {
            pos_handler(pos);
        }
    }
 }

-fn moves(board:&[Field, ..9], to_play:Field, move_handler:|uint, &[Field, ..9]|->()) {
+fn moves<F>(board:&[Field; 9], to_play:Field, move_handler:&mut F) where F : FnMut(usize, &[Field; 9]) {
    let mut new_board = *board;
-   free_pos(board, |pos| {
+   free_pos(board, &mut |pos| {
        new_board[pos] = to_play;
        move_handler(pos, &new_board);
        new_board[pos] = N;
    });
 }

-fn finished(board:&[Field, ..9]) -> bool {
+fn finished(board:&[Field; 9]) -> bool {
    if board.iter().find(|x| { **x == N }) == None {
        return true;
    }
@@ -85,14 +88,14 @@
    return false;
 }

-fn score(board:&[Field, ..9], player:Field, to_play:Field) -> u32 {
+fn score(board:&[Field; 9], player:Field, to_play:Field) -> u32 {
    let winner = find_winner(board);
    if winner == player { return 2; }
    if winner == other_player(player) { return 0; }

    let mut scores:Vec<u32> = vec![];
    let next_player = other_player(to_play);
-   moves(board, to_play, |_pos, new_board| {
+   moves(board, to_play, &mut |_pos, new_board| {
        scores.push(score(new_board, player, next_player));
    });

@@ -103,11 +106,11 @@
    }
 }

-fn best_move(rng:&mut rand::TaskRng, board:&[Field, ..9], player:Field) -> uint {
-   let mut scores:Vec<(uint, u32)> = vec![];
+fn best_move(rng:&mut rand::ThreadRng, board:&[Field; 9], player:Field) -> usize {
+   let mut scores:Vec<(usize, u32)> = vec![];
    let next_player = other_player(player);

-   moves(board, player, |pos, new_board| {
+   moves(board, player, &mut |pos, new_board| {
        scores.push((pos, score(new_board, player, next_player)));
    });

@@ -119,18 +122,21 @@

    let good_moves = scores.iter()
        .filter(|&&(_, score)| { score == max_score })
-       .collect::<Vec<&(uint, u32)>>();
+       .collect::<Vec<&(usize, u32)>>();

    let choice = Range::new(0, good_moves.len()).ind_sample(rng);
    let (pos, _) = *good_moves[choice];
    return pos;
 }

-fn read_move(reader: &mut io::Buffer, &board: &[Field, ..9]) -> Result<uint, io::IoError> {
+fn read_move(reader: &mut io::BufRead, &board: &[Field; 9]) -> Result<usize, io::Error> {
    loop {
        print!("X's move [0-8]: ");
-       match from_str::<uint>(try! { reader.read_line() }.as_slice().trim()) {
-           Some(n) => {
+       io::stdout().flush().ok().expect("Could not flush stdout");
+       let mut buffer = String::new();
+       try! { reader.read_line(&mut buffer) };
+       match buffer.trim().parse::<usize>() {
+           Ok(n) => {
                if n > 8 {
                    println!("out of range");
                } else if board[n] != N {
@@ -139,25 +145,25 @@
                    return Ok(n);
                }
            },
-           None => println!("enter an integer")
+           Err(_) => println!("enter an integer")
        }
    }
 }

-fn main_core() -> Result<int, io::IoError> {
-   let mut rng = rand::task_rng();
-   let mut board:[Field, ..9] = [
+fn main_core() -> Result<i32, io::Error> {
+   let mut rng = rand::thread_rng();
+   let mut board:[Field; 9] = [
        N, N, N,
        N, N, N,
        N, N, N,
    ];

-   let mut reader = io::stdin();
+   let reader = io::stdin();

    while !finished(&board) {
        show(&board);

-       let xmove = try!{ read_move(&mut reader, &board) };
+       let xmove = try!{ read_move(&mut reader.lock(), &board) };
        board[xmove] = X;
        if finished(&board) {
            break;