Scala Dojo - ThoughtWorks

Map.scala

package main.scala

import math.{ abs, min }
import Int.MaxValue

case class Map(val airports: Seq[(Int, Int)] = Seq(), val clouds: Seq[(Int, Int)] = Seq()) {
  
  def addAirports(coordinates: Seq[(Int, Int)]) = Map(airports ++ coordinates, clouds)

  def airportAt(coordinate: (Int, Int)) = airports.exists(_ == coordinate)

  def addClouds(coordinates: Seq[(Int, Int)]) = Map(airports, clouds ++ coordinates)

  def cloudAt(coordinate: (Int, Int)) = clouds.exists(_ == coordinate)

  private lazy val daysToAirport =
    for (airport <- airports) yield {
      for (
        cloud <- clouds;
        distanceX = abs(cloud._1 - airport._1);
        distanceY = abs(cloud._2 - airport._2);
        sumDistance = distanceX + distanceY
      ) yield sumDistance
    }.foldRight(MaxValue)(min)

  def daysToFirstAirport = daysToAirport.min

  def daysToLastAirport = daysToAirport.max
}

MapTest.scala

package test

import org.scalatest.WordSpec
import ashcloud.Map
import scala.collection.Seq.apply

class MapTest extends WordSpec {

  "map" should {

    "receive the coordinates for airports" in {
      val coordinates = Seq((0, 0), (1, 1))
      val map = Map()
        .addAirports(coordinates)
      assert(map.airportAt((0, 0)))
      assert(!map.airportAt((0, 1)))

    }

    "receive the coordinates for clouds" in {
      val coordinates = Seq((0, 0), (1, 1))
      val map = new Map()
        .addClouds(coordinates)
      assert(map.cloudAt((0, 0)))
      assert(!map.cloudAt((0, 1)))
    }

    "calculate correctly number of days to first airport in the case 1" in {
      val coordinatesClouds = Seq((0, 0))
      val coordinatesAirports = Seq((2, 1))
      val map = Map()
        .addClouds(coordinatesClouds)
        .addAirports(coordinatesAirports)
      assert(map.daysToFirstAirport == 3)
    }

    "calculate correctly number of days to first airport in the case 2" in {
      val coordinatesClouds = Seq((2, 2))
      val coordinatesAirports = Seq((2, 4))
      val map = Map()
        .addClouds(coordinatesClouds)
        .addAirports(coordinatesAirports)
      assert(map.daysToFirstAirport == 2)
    }

    "calculate correctly number of days to last airport in the case 1" in {
      val coordinatesClouds = Seq((0, 0))
      val coordinatesAirports = Seq((2, 1), (2, 4))
      val map = Map()
        .addClouds(coordinatesClouds)
        .addAirports(coordinatesAirports)
      assert(map.daysToLastAirport == 6)
    }

    "calculate correctly number of days to last airport in the case 2" in {
      val coordinatesClouds = Seq((0, 0))
      val coordinatesAirports = Seq((0, 1), (0, 2))
      val map = Map()
        .addClouds(coordinatesClouds)
        .addAirports(coordinatesAirports)
      assert(map.daysToLastAirport == 2)
    }
  }
}

Usando o paradigma funcional: objetos imutáveis e sem (var)iáveis.