Scala desde la perspectiva de C# y JavaScript, segunda parte

En la primera parte de esta serie vimos una primera introducción a Scala como lenguaje de programación definiendo algunas características de su sintaxis. En esta segunda parte pasaremos a la práctica utilizando una Code Kata.

En las artes marciales, se denomina kata a una representación, individual o colectiva, de un conjunto de movimientos. En disciplinas como el Karate se suelen enseñar en exhibiciones. El objetivo de las mismas es repetir los movimientos una y otra vez hasta que los mismos surjan de manera natural.

En programación, denominamos code kata a una definición de un problema relativamente simple, que resolvemos una y otra vez cuando estamos aprendiendo un lenguaje o una técnica como TDD. En este caso elegiremos una kata llamada Karate Chop, que define lo siguiente:

Dada una lista ordenada y un número, devolver la posición del mismo en la lista o -1 si no se encuentra, utilizando búsqueda binaria para ello.

El objetivo en este caso era ver si podía aprender lo mínimo necesario para poder escribir una solución a esta Kata utilizando Scala y utilizando la sintaxis de programación estructurada o orientada a objetos a la que estoy acostumbrado. Tras varias iteraciones agregando tests y condiciones, llegué al siguiente resultado:

	def chop (target: Int, searchBox: Array[Int]) : Int = {
	val size = searchBox.size
	if (size == 0) {
	return –1
	}

	if (size == 1){
	if(searchBox(0) == target){
	return 0
	} else {
	return –1
	}
	}

	val pointer = searchBox.size / 2
	val searchResult = searchBox(pointer)
	if(searchResult == target){
	return pointer
	}

	if (searchResult < target){
	val partialResult = chop(target, searchBox.slice(pointer, size))
	if(partialResult == –1)
	return –1

	return pointer + partialResult
	}

	if (searchResult > target){
	return chop(target, searchBox.slice(0, pointer));
	}

	return –1
	}

view raw

chop.scala

hosted with ❤ by GitHub

Para hacer las pruebas se suele usar un framework como ScalaTest, o recurrir a JUnit o TestNG de Java, que, como hemos mencionado anteriormente, son compatibles. En mi caso me limité a crear una pequeña función auxiliar que simplemente comparaba el resultado de la función y escribía por pantalla si había discrepancias:

	def assert(expected: Int, actual: Int){
	if(expected == actual){
	println("OK");
	}
	else {
	println("Error, expected: " + expected + " actual: "+ actual);
	}
	}

view raw

assert-chop.scala

hosted with ❤ by GitHub

Finalmente, para comprobar que el código «funciona» he usado el siguiente conjunto de casos de prueba:

	def main(args: Array[String]){
	test(–1, 2, Array.emptyIntArray)
	test(0, 1, Array(1,2,3,4,5))
	test(2, 3, Array(1,2,3,4,5))
	test(2, 3, Array(1,2,3))
	test(0, 1, Array(1))
	test(4, 5, Array(1,2,3,4,5))
	test(3, 4, Array(1,2,3,4,5))
	test(1, 2, Array(1,2,3,4,5))
	test(–1, 0, Array(1,2,3,4,5))
	test(–1, 7, Array(1,2,3,4,5))
	}

	def test(expected: Int, target: Int, searchBox: Array[Int]): Unit ={
	assert(expected, chop(target, searchBox))
	}

view raw

testcases-chop.scala

hosted with ❤ by GitHub

Escribiendo esta función aprendí varias cosas sobre Scala:

No necesitamos escribir el tipo de dato, ya que tenemos las palabras reservadas var para variables y val para objetos inmutables. Scala infiere el tipo de dato en tiempo de compilación por nosotros de la misma manera que lo hace C#, de manera que tenemos un sistema de tipos sólido y más sencillo de escribir.
Como curiosidades de sintaxis, el tipo de respuesta de una función lo definimos al final de la misma, en la definición de los parámetros también se declara primero el nombre y después el tipo, y el acceso a arrays se realiza mediante paréntesis en vez de corchetes.

#Conclusiones

Lo más importante que podemos ver en este ejemplo, es que no necesitamos cambiar nuestra manera de programar para comenzar a usar Scala, y que podemos ir agregando características funcionales de lenguaje a nuestro código poco a poco.

En el siguiente artículo de la serie volveremos a la teoría, retomando por donde lo habíamos dejado, viendo características como las Case Classes, el reconocimiento de patrones, y otros ejemplos de código, más funcionales que podemos encontrar en GitHub.

Mientras tanto, aquí están algunos enlaces sobre coding katas que he usado para hacer este artículo: