Scala
INTRODUCCIÓN
[Link]
Scala
¿Por qué usar Scala?
● Rápido y eficiente.
● Equilibrio entre productividad y rendimiento.
● Buen soporte para la programación funcional.
● Una sola línea de Scala puede reemplazar a
15-25 líneas en Java.
● Proporciona confianza al diseñar, desarrollar,
codificar e implementar.
● Facilidad para crear aplicaciones escalables al
estar diseñado pensando en el paralelismo y
la concurrencia. 2
Scala
Valores
Son el método predeterminado para almacenar datos, son inmutables y no es necesario definir
el tipo de dato ya que Scala cuenta con inferencia de tipos.
Sintaxis: val<nombre>[:<tipo>]=<expresión>
Ejemplo:
Tipo definido -> val x: Int = 20
Sin indicar tipo -> val x = 20
La inferencia de tipos no anula la definición explícita por lo que, a la hora de asignar datos
los tipos deben coincidir.
Error
val x:Int = "Hola"
found : String("Hola")
required : Int val
x:Int= "Hola"
3
Scala
Variables
Se trata de un identificador único que apunta a un espacio de memoria asignado en el que se puede almacenar y
leer valores, siempre que el espacio de memoria asignado esté disponible se puede reasignar valores tantas
veces como se requiera, por tanto, a diferencia de los valores que eran inmutables, las variables son dinámicas,
mutables y reasignables.
Con las variables ocurre lo mismo que con los valores, si se define el tipo de la variable se asigna un tipo incorrecto
de dato, se produce un error.
Sintaxis: val<nombre>[:<tipo>]=<expresión>
Definición de una variable:
scala> var x = 5
x: Int = 5
scala> x = "what's up?"
<console>:8: error: type mismatch;
found : String("what\'s up?")
required: Int
x = "what's up?"
4
Scala
Nombres
Cuando queremos asignar un nombre a nuestras variables/valores al crearlos en Scala, estos
solo pueden contener letras, números, constantes y algunos caracteres de operador especiales.
Se debe tener en cuenta una serie de normas:
● Una letra seguida de cero o más letras y dígitos.
● Una letra seguida de cero o más letras y dígitos seguido de un guión bajo y una o más
letras/dígitos/caracteres operadores.
● Uno o más caracteres de operador.
● Uno o más caracteres excepto una comilla invertida.
Ejemplo:
scala> val π = 3.14159
π: Doble = 3,14159
scala> val o_O = "Ejemplo"
o_O: Cadena = Ejemplo
5
Scala
Tipos de datos - Numéricos
Scala admite la conversión automática de tipos entre números basada en
rangos, en la tabla podemos observar que se encuentran ordenados de
menor a mayor siendo el tipo Byte el que tiene el rango más bajo, esta
conversión de tipo siempre se debe realizar desde el rango más bajo a un
tipo con rango más alto ya que de lo contrario se produce un error debido a
que un tipo con menos capacidad de almacenamiento no puede admitir uno
de mayor rango.
6
Scala
Tipos de datos - Literales Numéricos
Son una alternativa al uso explícito de tipos, de esta manera especificamos
directamente el tipo de sus datos literales directamente usando la notación
que nos ofrece Scala. Los caracteres literales no son sensibles a mayúsculas
y minúsculas por lo que el literal 5f es igual a 5F.
7
Scala
Tipos de datos - Cadenas y otro datos no numéricos
Los tipos cadena representan un conjunto de caracteres, el tipo más común
es el tipo String de Scala el cual tiene características como la interpolación
de cadenas o las literales multilíneas, admite el uso de operadores
matemáticos por ejemplo el uso de operador “==” para comparar cadenas.
Se puede crear cadenas de varias líneas utilizando la notación de triple
comilla “””, estas cadenas son lo que se conoce como literales de cadena.
8
Scala
Tipos de datos - Tuplas
Scala tiene tanto tipos numéricos como no numéricos, estos tipos básicos son
la unidad básica para los demás tipos de datos incluidos los objetos y
colecciones a continuación, se muestran varias tablas con los diferentes tipos
de datos que podemos usar en Scala:
9
Scala
Expresiones
Unidad de código que devuelve un valor después de ser ejecutado, una o
varias líneas pueden considerarse una expresión si están rodeadas por llaves
{ }, esto se conoce como bloque de expresión.
Ejemplo 1
Scala> “Hola”
Res0: String = Hola
Ejemplo 2
Scala> “Ho” +”l”+”a”
Res1: String = Hola
10
Scala
Expresiones de bloque
En Scala se puede combinar varias expresiones utilizando { } para crear un
único bloque de expresión, las expresiones tienen su propio ámbito y puede
contener valores y variables locales del propio bloque, su última expresión es
la que genera la salida de todo el bloque completo.
Ejemplo:
value: scala> val amount = {val x = 5 * 20; x + 10}
amount: Int = 110
11
Scala
Bloques IF-ELSE
Los bloques IF-ELSE se utilizan para elegir una rama del código en función de
una expresión de evaluación que se resuelve como verdadera o falsa, en
muchos lenguajes este tipo de expresiones se define como una sentencia if
seguida de uno else o varios else if.
12
Scala
Expresión IF
Sintaxis: If(<expresión booleana>) <expresión>
En caso de usar únicamente la expresión if nos encontramos con el problema
de no devolver nada en caso de que no se cumpla la condición.
Esto provoca que el compilador tenga que inferir el tipo de dato más
apropiado para la salida.
Ejemplo if:
scala> val res = if(false) ”¿Cuál es el resultado?”
res: Any = ()
13
Scala
Expresión IF-ELSE
Para solucionar el problema del único If podemos utilizar la sentencia de if-
else.
Sintaxis:
If(<expresión booleana>) <expresión>
else<expresión>
Ejemplo 1
Scala> val x=10; val y=20
X:Int = 10
Y:Int = 20
Scala> val max = if(x > y) x else y
max: Int = 20
14
Scala
Expresión de coincidencia
Son sentencias en las que se evalúa un único elemento de entrada y se ejecuta el
primer patrón de coincidencia y se devuelve su valor al igual que la sentencia
Switch de C y Java, la principal diferencia es que en Scala admite un patrón por
defecto o comodín “catch-all” a diferencia de los otros lenguajes que solo admiten
uno.
Sintaxis:
<expresión>
match{
case <expresión de coincidencia> => <expresión>
[case...]
}
Otorgan:
● Potencia
● Flexibilidad 15
Scala
Expresión de coincidencia
Se puede combinar varios patrones junto con un patrón alternativo, en el que
el bloque de casos se activará si alguno de los patrones coincide.
Ejemplo:
i=5
val result = i match{
case 1|3|5|7|9 => println("Impar")
case 2|4|6|8|10 =>println("Par")
case_=>println("Otro")
}
Result: String = Impar
16
Scala
Expresión de coincidencia
Es importante tener en cuenta que, en caso de que no se encuentre un patrón que coincida con la
expresión de evaluación, el compilador de Scala arrojará un error de ejecución [Link] que nos
indica que se trata de un fallo de la expresión de equivalencia.
Para evitar este tipo de errores se recomienda añadir los suficientes patrones para cubrir todas las
posibilidades o usar match-all.
Ejemplo:
scala> val message = "Ok"
message: String = Ok
scala> val status = message match {
case "Ok" => 200
case other => {
println(s"Couldn't parse $other")
-1
}
}
Status: Int = 200
17
Scala
Coincidencia de patrones comodín
Sintaxis vinculación de variables
case<identificador> => <una o más expresiones>
Ejemplo:
scala> val message = "Ok"
message: String = Ok
scala> val status = message match {
case "Ok" => 200
case other => {
println(s"Couldn't parse $other")
-1
}
}
Status: Int = 200
18
Scala
Coincidencia con patrones comodín
Sintaxis comodines
case_ => <una o más expresiones>
Ejemplo:
scala> val message = "Ok"
message: String = Ok
scala> val status = message match {
case "Ok" => 200
case _=> {
println(s"Couldn't parse $message ")
-1
}
}
Status: Int = 200
19
Scala
Coincidencia con patrones guardas
Sintaxis
case <expresión> if <expresión booleana> => <una o más expresiones>
Ejemplo:
scala> val response: String = null
response: String = null
scala> response match {
case s if s != null => println(s “Received ‘$s’”)
case s => println(“Error! Received a null response”)
}
Error! Received a null response
20
Scala
Coincidencia de tipos de patrón variable
Ejemplo:
scala> val x: Int = 12180
x: Int = 12180
scala> val y: Any = x
y: Any = 12180
scala> y match {
case x: String => s"'x'"
case x: Double => f"$x%.2f"
case x: Float => f"$x%.2f"
case x: Long => s"${x}l"
case x: Int => s"${x}i"
}
res9: String = 12180i
21
Scala
Bucles
Un bucle es una estructura de control que ejecuta una secuencia de instrucciones de manera repetida.
Sintaxis
Iteración en un rango de valores
<valor de inicio>[to|until]<valor final>[incremento]
Iteración con un for básico
for(<identificador><-<iterador>)[yield][<expresión>]
Ejemplo for básico con llaves:
scala> for (x <- 1 to 7) {println(s”Day $x:”)}
Ejemplo for con yield:
scala> for(x <- 1 to 7) yield {s “Day $x:”}
Ejemplo imprimir datos generados por yield:
scala> for(day <- (for(x <- 1 to 7) yield {s"Day $x:"})) print(day + ", ")
22
Scala
Iteradores con guardas
Una guarda dentro de un for aplica un ”filtro” al iterador, garantiza la continuidad del bucle mientras la
condición del IF devuelve verdadero.
Sintaxis:
for(<identificador> <- <iterador> if <expresión booleana>). . .
Ejemplo:
scala> val multiplos_2 = for(x <- 0 to 20 if x % 2 == 0) yield x
println(multiplos_2)
scala> for {
t <- [Link](",")
if t!= null
if [Link] > 0
}{println(t)}
23
Scala
Itinerarios anidados
Se trata de iteradores extra que se añaden a un bucle for, esto multiplica el número de iteraciones por el
número de iteradores que posea el bucle.
Ejemplo:
scala> for {
x <- 1 to 3
y <- 1 to 3
z <- 1 to 3
}{println(s"$x,$y,$z")}
24
Scala
Vinculación de valores
Nos permite declarar valores o variables temporales dentro de la definición del bucle for.
Sintaxis:
for(<identificador><- <iterador>; <identificador> = <expresión>). . .
Ejemplo:
scala> val valores = for(i <- 0 to 7; suma = 1 + i) yield suma
println(valores)
25
Scala
Bucles While y Do/While
Se trata de otra estructura de control de Scala que se encarga de repetir una secuencia de código hasta
que la expresión booleana devuelva falso.
Sintaxis:
while(<expresión booleana>) código
Ejemplo:
scala> var x = 10
scala> while(x > 10) x -= 1
El bucle Do/While es similar, la diferencia está en que la ejecución se produce antes de la evaluación de
la expresión booleana.
Ejemplo:
var x = 0
do println(s"El valor de la x es $x") while(x > 0)
26
Scala
Bucles While y Do/While
Las funciones son el núcleo de la lógica de código reutilizable, los lenguajes de programación funcional
están orientados a apoyar la creación de funciones altamente reutilizables y compatibles y a ayudar a los
desarrolladores a organizar su base de código en torno a ellas.
Sintaxis:
def <identificador> = <expresión>
Sintaxis función con return:
def<identificador>:<tipo> = <expresión>
Sintaxis extensa:
def<identificador>:(<identificador>:<tipo>[, …]): <tipo> = <expresión>
27
Scala
Procedimientos
Se trata de funciones que no devuelven un valor, cualquier función que termine con una declaración
como una llamada a println() o similares, es un procedimiento.
Ejemplo:
scala> def log (d: Double) = println(f"Obtener valor $d%.2f")
28
Scala
Funciones sin parámetros
Se trata de funciones sin parámetros de entrada que se definen con paréntesis vacíos, esta es una buena
forma de definición ya que permite distinguir claramente la función.
Sintaxis
def <identificador>()[:<tipo>] = <expresión>
La llamada a una función se puede hacer sin los paréntesis.
Ejemplo:
scala> def hola(): String = “Hola”
hola:() String
scala> hola()
res0: String = Hola
scala> hola
res1: String = Hola
29
Scala
Funciones sin parámetros
Por el contrario, una función creada sin paréntesis no puede ser llamada con ellos.
Ejemplo:
scala> def hola2: String = “Hola de nuevo”
hola2: String
scala> hola2()
[Link][Link] error: not enough arguments for method apply: (i: Int)Char in class
StringOps.
Unspecified value parameter i.
hola2()
30
Scala
Funciones de expresiones en bloque
Al llamar a funciones de un solo parámetro se puede optar por usar un bloque de expresión rodeado por
llaves, el uso del bloque de expresión nos permite realizar cálculos u otras acciones en la llamada a la
función.
Sintaxis
<identificador de la función><expresión de bloque>
Ejemplo:
scala> def redondeo(valor: Double) = f"$valor%.2f"
scala> println(redondeo{var v = 2.45; v * 1.25})
31
Scala
Funciones recursivas
Es aquella función que puede invocarse a sí misma y que contiene algún tipo de parámetro o condición
que le permite evita un bucle infinito de invocación.
Ejemplo:
scala> def potencia (x: Int, n: Int): Long = {
if (n>=1) x*potencia (x, n-1)
else 1
}
potencia(2, 8)
res0: Long =256
32
Scala
Funciones recursivas
Scala usa tail-recursion que nos ayuda a optimizar algunas funciones recursivas, con tail-recursion las
invocaciones recursivas no crean un nuevo espacio en la pila, sino que utiliza el espacio de pila de la
llamada actual, solo se puede optimizar aquellas funciones cuya última sentencia es la que provoca la
invocación recursiva.
Debemos usar @[Link] para indicar que queremos optimizar nuestra función.
Ejemplo tail-recursion
scala> @[Link]
def potencia (x: Int, n: Int, t: Int): Long = {
if (n<1) t
else potencia (x, n-1, t*x)
}
33
Scala
Funciones anidadas
Funciones que poseen otras funciones internamente y que son de uso local, es decir, el funcionamiento
se restringe a la función contenedora sin la posibilidad de ser llamadas por un método externo.
Ejemplo:
scala> def max(a: Int, b: Int, c: Int) = {
def max(x: Int, y: Int) = if (x > y) x else y
max(a, max(b, c))
}
max: (a: Int, b: Int, c: Int)Int
scala> max(22, 821, 1)
res0: Int = 821
34
Scala
Llamada a funciones por nombre de parámetros
A diferencia de otros lenguajes Scala permite realizar llamadas a funciones colocando sus parámetros en
distinto orden a como se definieron originalmente, esto se realiza especificando el nombre del argumento
en la llamada.
Sintaxis
<nombre de la función><parámetro>=<valor>
Ejemplo:
scala> def prueba (cad1: String, cad2: String) = s“$cad1 $cad2”
Prueba: (cad1: String, cad2: String)String
scala> val original = prueba (“Esto es una”, “prueba”)
scala> val distintoOrden = prueba (cad2 = “prueba”, cad1 = “Esto es una”)
35
Scala
Parámetros vararg
Los parámetros vararg ayudan a llamar a una función con cero o varios parámetros sin la necesidad de
definirlos en la función.
Ejemplo:
scala> def suma(items: Int*): Int = {
var total = 0
for(i <- items) total += i
total
}
suma: (elementos: Int*)Int
scala> suma (5, 10, 15)
res1: Int = 30
scala> suma ()
res2: Int = 0
36
Scala
Funciones de primer nivel
Scala tiene soporte completo para funciones de primer nivel, funciones de orden superior y programación
declarativa, Al igual que con otros tipos de datos como String o Int, las funciones tienen tipos basados en
los tipos de sus argumentos de entrada y su valor de retorno. Una función puede almacenarse en un
valor o variable, pasarse a una función, devolverse desde una función, y con estructuras de datos para
soportar map(), reduce(), fold(), y filter(), entre muchas otras funciones de orden superior.
37
Scala
Funciones de orden superior
Una función de orden superior es una función que tiene un valor con un tipo de función como parámetro
de entrada o valor de retorno.
Un ejemplo de uso sería llamar a otras funciones que actúan sobre una cadena, pero sólo si la cadena de
entrada no es nula.
scala> def safeStringOp(s:String, f:String => String) = {
If(s != null) f(s) else s
}
safeStringOp: (s:String, f:String=>String)String
scala> def reverser(s:String) = [Link]
reverser: (s:String)String
scala> safeStringOp(null, reverser)
res0: String = null
scala> safeStringOp(“Hola”, reverser)
res1: String = aloH 38
Scala
Funciones literales
Un literal es una sintaxis alternativa para definir una función, resulta útil para cuando queremos pasar
una función como argumento a un método, pero no queremos definirla de forma separada, los literales
de funciones son anónimos, no tienen un nombre por defecto, pero puede asignarles un nombre
vinculándolos a una variable.
Sintaxis
([<identificador>: <tipo>, …]) => <expresión>
Ejemplo:
scala> val cuadrado = (x: Int) = > x * x
cuadrado: Int => Int = <función>
scala> val resultado = cuadrado(9)
resultado: Int = 81
39
Scala
Funciones literales
Los literales tienen varios nombres he aquí algunos de ellos:
● Funciones anónimas
Aquellos literales que no tienen nombre de función, en Scala es el nombre formal por el que se los
conoce.
● Expresiones lambda
Usado término usado por lenguajes como C# y Java derivado de la sintaxis original del cálculo lambda.
● Funcion0, funcion1, funcion2
Termino de Scala para los literales de función, basado en el número de argumentos de entrada. En
nuestro ejemplo anterior sería <funcion1>.
40
Scala
Funciones literales
Podemos definir literal sin argumentos de entrada.
scala> val start = () => "=" * 50 + "\nStarting NOW\n" + "=" * 50
start: () => String = <función>
scala> println(start())
41
Scala
Sintaxis de marcadores de posición
Se trata de una sintaxis abreviada de funciones literales, en la que se sustituye los parámetros con
nombre por el comodín (_) puede usarse en dos casos, cuando el tipo explícito de la función se especifica
fuera del literal y cuando los parámetros no se usan más de una vez.
Ejemplo1:
scala> val triple: Int => Int = _ * 3
triple: Int=> Int = <función1>
Ejemplo2:
scala> def safeStringOp(s :String,f:String =>String) = {
If(s!=null) f(s) else s
}
scala> safeStringOp(null, _.reverse)
res0: String = null
scala> safeStringOp(“Hola”, _.reverse)
res1: String = aloH
42
Scala
Funciones parcialmente aplicadas y currificadas
Sirven para conservar algunos de los parámetros de una función, de esta forma podemos evitar tener
que volver a escribirlos, para conservarlos haremos uso del comodín (_) seguido de la definición explicita
de tipo.
Ejemplo:
scala> val multipleOf3 = factorOf(3, _: Int)
multipleOf3: Int => Boolean = <función>
scala> val y = multipleOf3(78) y: Boolean = true
43
Scala
Funciones literales
Una forma más limpia de aplicar parcialmente las funciones es utilizar funciones con listas de parámetros
múltiples, en lugar de dividir la lista de parámetros en parámetros aplicados y no aplicados.
scala> def factorOf(x: Int)(y: Int) = y % x == 0
factorOf: (x: Int)(y: Int)Boolean
scala> val isEven = factorOf(2) _
isEven: Int => Boolean = <funcion1>
scala> val z = isEven(32)
z: Boolean = true
44
Scala
Parámetros by-name
Se trata de una forma alternativa de parámetro en la que puede tomar un valor o una función que
devuelve un valor, al admitir estas dos formas de invocación queda a elección del invocador porque
opción optar.
Sintaxis
<identificador>: => <tipo>
Cada vez que se utiliza un parámetro by-name dentro de una función, se evalúa en un valor.
45
Scala
Parámetros by-name
Se debe tener en cuenta el coste de la función parámetro y los accesos repetidos a su función, la
principal ventaja de los parámetros by-name a diferencia de los parámetros por valor o funciones es la
flexibilidad que proporciona.
Ejemplo:
def doubles(x: => Int) = {
println("Now doubling " + x)
x*2
}
def f(i: Int) = {println(s"Hello from f($i)"); i}
def main(args: Array[String]) {
println(doubles(f(8)))
}
46
Scala
Funciones totales y parciales
Las funciones totales son todas aquellas funciones que admiten adecuadamente todos los valores
posibles que cumplen el tipo de los parámetros de entrada. Sin embargo, hay algunas funciones que no
admiten todos los valores posibles, aunque cumplen los tipos de entrada a estas funciones se las conoce
como parciales.
Ejemplo:
scala> val statusHandler: Int => String = {
case 200 => "Bien"
case 400 => "Su error"
case 500 => "Nuestro error"
}
statusHandler: Int => Cadena = <función1>
scala> statusHandler(401)
[Link]: 401 (de la clase [Link])
at $anonfun$[Link](<consola>:7)
at $anonfun$[Link](<consola>:7)
47
Scala
Colecciones
El framework de colecciones proporciona estructuras de datos para recoger uno o más valores de un tipo
determinado, muchos lenguajes tienen su propio framework de colecciones ya que son los bloques de
construcción de los proyectos de software modernos.
● Lists
● Sets
● Maps
48
Scala
Lists
Son colecciones de Scala que tienen las siguientes características:
● Todos los elementos de la lista tienen el mismo tipo.
● Son inmutables por lo que no se puede reasignar valores.
● Representan una lista vinculada.
● No mantienen el orden.
● No se puede acceder a la lista por su índice.
Sintaxis
scala> val <identificador> = List(valor_0, valor_1, valor_2, …)
Ejemplo:
scala> val colors = List("red", "green", "blue")
colors: List[String] = List(red, green, blue)
49
Scala
Set
Se trata de una colección de datos que no permite añadir valores repetidos.
Características:
● Por defecto inmutable.
● No mantiene el orden.
● No se puede acceder mediante su índice.
● No admite duplicados.
Sintaxis:
var s:Set[<tipo>]=Set()
Ejemplo:
var s = Set(1,4,4,3)
s: Set[Int] = Set(1, 4, 3)
50
Scala
Maps
Es una colección de pares clave/valor.
Características:
● Las claves son únicas.
● Los valores se acceden mediante su clave.
● Admite valores repetidos.
● Pueden ser inmutables y mutables.
Sintaxis
val <identificador> = Map(K1->V1, K2->V2, K3->V3. . .)
Ejemplo:
val datos = Map(“Ana” -> 693747362, “Mario” -> 674123428, “Bea” -> 633547362)
51
Scala
Listas - Operaciones aritméticas
52
Scala
Listas mapeadas
Los métodos Map son los que toman una función y la aplican a cada elemento de una lista, recogiendo
los resultados en una nueva lista, mapear hace referencia a la creación de una asociación entre cada
elemento de un conjunto y cada elemento de otro conjunto, de esta manera en el caso de List, mapea
cada elemento de una lista a otra lista, de modo que la segunda tenga el mismo tamaño que la primera,
pero con diferentes datos o tipos de elementos.
53
Scala
Listas reducidas
Este método es una acción reduce que ayuda a compactar todo el trabajo realizado en un solo valor, se
trata de una operación común para trabajar con colecciones, en Scala las colecciones soportan
operaciones de reducción matemática y operaciones de reducción booleana, también admiten
operaciones genéricas de orden superior conocidas como folds, que se pueden usar para crear cualquier
tipo de algoritmo de reducción de listas.
54
Scala
Listas reducidas
Operaciones de reducción matemáticas Operaciones genéricas de listas
Operaciones de reducción booleana
55
Scala
Conversión de colecciones
Existe la posibilidad de convertir un tipo de colección en otro diferente, a continuación, se muestran
operaciones que nos ayudan en la conversión, de esta manera podemos mapear colecciones.
56
Scala
Patrones de coincidencia con colecciones
Como hemos explicado anteriormente el uso de expresiones de coincidencia es muy útil, con las
colecciones podemos hacer uso de estos patrones ya que admiten operadores de coincidencia y
comparación para hacer coincidir toda la colección.
Ejemplo:
scala> val msg = statuses match {
case List(404, 500) => "not found & error"
case List(500, 404) => "error & not found"
case List(200, 200) => "okay"
case _ => "not sure what happened"
}
msg: String = error & not found
57
Scala
Patrones de coincidencia con colecciones
Podemos utilizar vinculación de valores para vincular valores a algunos o todos los elementos de una
colección en su patrón guarda.
Podemos hacer coincidir la lista por cabeza y cola.
Ejemplo:
scala> val head = List('r','g','b') match {
case x :: xs => x
case Nil => ' '
}
head: Char = r
58
Scala
Patrones de coincidencia con colecciones
Las tuplas, también admiten la equivalencia de patrones y la vinculación de valores. Dado que una
misma tupla puede admitir valores de distintos tipos, su capacidad de comparación de patrones es a
veces incluso más útil que la de las colecciones:
scala> val code = ('h', 204, true) match {
case (_, _, false) => 501
case ('c', _, true) => 302
case ('h', x, true) => x
case (c, x, true) => {
println(s"Did not expect code $c")
X
}
}
code: Int = 204
59
[Link]
