7 languages in 7 weeks: Scala day 1

I went to a great talk by Sandro Mancuso at Devoxx UK last week. He mentioned the project he is currently working on being written in Java for the main business flow and Scala for the data manipulation (sorry if I have remembered that incorrectly). This got me thinking it was about time I learnt some Scala. I've dipped in and out of the 7 languages in 7 weeks book; fortunately it has a chapter on Scala. So here I go...

 Googling around and reading the first day the following stands out:

• Type inference with the safety of static typing (we're all sick of typing types aren't we??)
• Companion objects instead of static methods
• Higher order functions (why do we need lambas? Can't we just switch to Scala?)
• Interfaces, no I mean mixins, wait traits: interfaces with implementation? I think these are great when used well.
• Tuples and ranges.

So on to my home work!

The exercise for day 1 is to write noughts and crosses. I decided to concentrate on setting up a nice environment for writing scala rather than great code. I started with vim, then sublime but decided I fancied using an IDE. I started with Eclipse but moved to IntelliJ as it looks nicer on a retina screen :) In  addition to setting up an IDE I wanted to do TDD from the start, so I got to grips with ScalaTest.

Here are a couple of example tests:

	class BoardSuite extends FunSuite with BeforeAndAfter {
	var board : Board = _
	before {
	board = new Board
	}
	test("A board is initialized to blank") {
	board.moves.foreach(row => row.foreach(box => assert(box === Player.B)))
	}
	test("Making the first move is marked X") {
	board.move(1, 1)
	assert(board.moves(1)(1) === Player.x)
	}
	test("Making the second move is marked o") {
	board.move(1, 1)
	board.move(1, 2)
	assert(board.moves(2)(1) === Player.o)
	}
	test("Cant use the same place twice") {
	board.move(1, 1)
	intercept[RuntimeException] {
	otherPlayersMove(1, 1)
	}
	}
	test("No winner after no moves") {
	val winner = board.winner()
	println(board)
	assert(winner === Player.B)
	}
	test("Win vertical line on left") {
	board.move(0,0)
	otherPlayersMove(1,0)
	board.move(0,1)
	otherPlayersMove(1,1)
	board.move(0,2)
	println(board)
	assert(Player.x === board.winner)
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Here is the main Board object. I could pull out the logic to determine a winner into a class like Game but as this was my first Scala code I decided to keep it simple in a single file.

	package com.batey.sevenlanguages.scala.dayone
	object Player extends Enumeration {
	type Player = Value
	val x, o, B = Value
	}
	import com.batey.sevenlanguages.scala.dayone.Player._
	class Board() {
	val size = 3
	var moves = Array.ofDim[Player](size,size)
	var nextMove = Player.x
	moves.foreach(arg => {
	for (i <- 0 until arg.length) {
	arg(i) = Player.B
	}
	})
	override def toString() : String = {
	val toReturn = new StringBuilder
	for (i <- 0 until size) {
	moves(i).foreach(col => toReturn ++= col + " ")
	toReturn ++= "\n"
	}
	toReturn.toString
	}
	def move(x:Int, y:Int) = {
	if (moves(y)(x) != Player.B) {
	throw new RuntimeException("Move already made")
	}
	moves(y)(x) = nextMove
	if (nextMove == Player.x) {
	nextMove = Player.o
	} else {
	nextMove = Player.x
	}
	}
	def winner() : Player = {
	var win = horizontalWin
	if (win != Player.B) return win
	win = verticalWin
	if (win != Player.B) return win
	win = diagWinFromTopLeft
	if (win != Player.B) return win
	diagWinFromTopRight
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

I've omitted the code that calculates the different types thought it's all available on github. I looked at using a case class rather than a class that extends Enumeration but I haven't been taught case classes yet  so I'll leave that until later.

That's it for day one!