Tema 6: Programación funcional en Scala

Transcripción

1 Tema 6: Programación funcional en Scala Sesión 17: Introducción a Scala (1) martes 5 de abril de 2011 Referencias Programming in Scala. Martin Odersky, Lex Spoon, Bil Venners. Ed. Artima. Programming Scala. Dean Wampler, Alex Payne. Ed. O'Reilly. Scala by Example. Martin Odersky. November A Scala Tutorial for Java programmers. Michel Schinz, Philipp Haller. November The Scala Language Specification. Martin Odersky. November martes 5 de abril de 2011

2 El lenguaje de programación Scala Se desarrolla en 2001 en la universidad EPFL (Suiza) por un equipo dirigido por Martin Odersky El objetivo principal del lenguaje es integrar el paradigma funcional y el paradigma orientado a objetos Énfasis en la facilidad del desarrollo de componentes reusables Está basado en Java: los programas en Scala se compilan a bytecodes de Java y se ejecutan en la máquina virtual Java Sus características funcionales lo hacen muy apropiado para desarrollar programas muy eficientes en arquitecturas paralelas formadas por granjas de múltiples ordenadores (Twitter usa Scala) Sitio web: martes 5 de abril de 2011 Unificación de PF y POO Programación funcional: hace fácil desarrollar cosas interesantes desde partes sencillas, usando: funciones de orden superior tipos algebraicos y pattern matching polimorfismo paramétrico Programación orientada a objetos: hace fácil adaptar y extender sistemas complejos, usando: martes 5 de abril de 2011 especialización (subclases) y herencia configuraciones dinámicas clases como abstracciones parciales

3 Diseño de Scala Lenguaje moderno que satisface las necesidades más importantes de los desarrolladores actuales Completamente compatible con Java Modelo de objetos uniforme Pattern matching Funciones de orden superior Nuevas formas para abstraer y componer programas martes 5 de abril de 2011 Características de Scala Estáticamente tipeado, con características de scripting porque en muchas ocasiones el compilador realiza una inferencia de tipos Interoperabilidad: encaja perfectamente en un entorno Java. Conciso // Java class MyClass{ private int index; private String name; } public MyClass(int index, String name){ this.index = index; this.name = name; } // Scala class MyClass(index: Int, name: String) martes 5 de abril de 2011

4 Scala utiliza la PF Un par de ejemplos con funciones de orden superior: //Java boolean namehasuppercase = false; for (int i=0; i<name.length(); ++i){ if(character.isuppercase(name.charat(i))){ namehasuppercase = true; break; } } //Scala val namehasuppercase = name.exists(_.isuppercase) martes 5 de abril de 2011 Scala utiliza la PF scala> val matrix = Array(Array(1, 0, 0), Array(0, 1, 0), Array(0, 0, 1)) matrix: Array[Array[Int]] = Array ([I@164da25,... scala> matrix.exists(row => row.forall(0 ==)) res13: Boolean = false martes 5 de abril de 2011

5 Scala es orientado a objetos A diferencia de Java o C++ en Scala no existen tipos primitivos que no son objetos Todas las expresiones se compilan a llamadas a métodos de objetos scala> (1).hashCode res8: Int = 1 scala> (1).+(2) res10: Int = 3 Veremos más detalles de POO en Scala en los últimos tema de la asignatura martes 5 de abril de 2011 Scala como intérprete y compilador Scala permite ejecutar sus programas en modo scripting o en modo compilado Hasta ahora hemos usado el intérprete de Scala Cada línea de código es compilada y se genera bytecode que es ejecutado por la MV Java martes 5 de abril de 2011

6 Scala como intérprete y compilador Se puede llamar a un script de Scala con el comando scala println("hola, "+ args(0) +"!") args.foreach(arg => println(arg)) También es posible utilizar el compilador de Scala explícitamente, con el comando scalac helloworld.scala: // Definimos un singleton: una clase con un único objeto object HelloWorld { def main(args: Array[String]) { println("hello, world!") } } $ scalac helloworld.scala $ scala HelloWorld martes 5 de abril de 2011 Expresiones y funciones simples en el intérprete El intérprete analiza las expresiones, realiza las inferencias de tipos necesarias y evalua la expresión: scala> * 3 scala> * 3 scala> "hola" + " mundo!" martes 5 de abril de 2011

7 Tema 6: Programación funcional en Scala Sesión 18: Programación funcional en Scala Referencias Programming in Scala. Martin Odersky, Lex Spoon, Bil Venners. Ed. Artima. Programming Scala. Dean Wampler, Alex Payne. Ed. O'Reilly. Scala by Example. Martin Odersky. November A Scala Tutorial for Java programmers. Michel Schinz, Philipp Haller. November The Scala Language Specification. Martin Odersky. November 2010.

8 Expresiones y funciones simples en el intérprete El intérprete analiza las expresiones, realiza las inferencias de tipos necesarias y evalua la expresión: scala> * 3 scala> * 3 scala> "hola" + " mundo!" Variables mutables e inmutables Scala diferencia entre variables inmutables (declaradas con val y variables mutables var) Es recomendable utilizar siempre que podamos variables inmutables (val), esto refuerza el carácter funcional de nuestros programas Las variables son estrictamente tipeadas, aunque no es necesario declarar el tipo porque Scala puede inferirlo

9 Variables mutables e inmutables scala> val msg = "Hola mundo!" msg: java.lang.string = Hola mundo! scala> var saludo = "Hola mundo!" saludo: java.lang.string = Hola mundo! scala> saludo = "Hasta luego!" saludo: java.lang.string = Hasta luego! scala> saludo = 3.0 <console>:5: error: type mismatch; found : Double(3.0) required: java.lang.string Variables mutables e inmutables Cuidado! El intérprete permite declarar varias veces la misma variable. Cada ejecución de una nueva sentencia crea un nuevo ámbito en el que se define la nueva variable. Las variables anteriores se pierden. Esto no es correcto en un programa; una variable sólo se puede declarar una vez. Las variables declaradas con val no pueden ser reasignadas. Esto no impide que cambie el valor del objeto que contienen (en el caso de estar en el paradigma imperativo). Ejemplo: scala> val a = Array(1,0,0) a: Array[Int] = Array(1, 0, 0) scala> a(1) = 1 scala> a res42: Array[Int] = Array(1, 1, 0)

10 Tipos de datos básicos Aunque hablemos de tipos de datos, en Scala todos los tipos de datos son clases Algunos tipos de datos y formas de inicializarlos: Tipo de dato Rango Ejemplo Byte 8-bit con signo 38 Short 16-bit con signo 23 Long 64-bit con signo Int 32-bit con signo 70 Char 16-bit sin signo A Float 32 bit flotante con signo Double 64 bit flotante con signo Boolean true o false true String secuencia de caracteres hola El API completo de Scala se puede consultar en api/current/index.html Operadores Aritméticos: + - = * % Relacionales: < <= > >=!= == Lógicos: &&!

11 def para dar nombre a expresiones def es una primitiva declarativa: le da un nombre a una expresión, pero no la evalua La evaluación se realiza cuando se llame al identificador def t = 8 / 0 --> No da error t --> al evaluar t, error división por cero En el caso de val o var la evaluación se realiza antes de hacer la asignación val t = 8 / 0 --> error Cuándo se evalúan las variables en un def? Las variables en una expresión definida por def se evaluan cuando se invoca al identificador definido: var x = 10 def t = x / 5 var x = 5 t -> 1

12 def para definir funciones Sintaxis: def <nombre_funcion>(<parametro1:tipo1>,...):<tipo_resultado>={ <cuerpo de la función> } Ejemplo: def max(x: Int, y: Int): Int = { if (x > y) x else y } max: (Int,Int)Int def para definir funciones Las llaves son opcionales si el cuerpo tiene una sóla sentencia El tipo de retorno es opcional si Scala puede inferirlo (no aplicable a funciones recursivas) scala> def max2(x: Int, y: Int) = if (x > y) x else y max2: (Int,Int)Int La función se evalúa cuando se invoca: scala> max2(3, 5) res6: Int = 5 Los ejemplos anteriores en los que se definían expresiones se pueden interpretar de esta manera: como una definición de una función de una única sentencia (la expresión) que se evalua cuando se invoca

13 Una función que no devuelve nada Por ahora todas las funciones que vamos a definir van a estar en el paradigma funcional, siempre devolverán algún valor Sin embargo Scala es también procedural: scala> def hola() = println("hola mundo") hola: ()Unit La función hola no devuelve ningún valor; la clase Unit es similar al tipo void de Java Expresiones condicionales: if if: condicional; cuidado con el fin de línea si no utilizamos llaves Correcto: def abs(x: Double) = if (x >= 0) x else -x Incorrecto: def abs(x: Double) = if (x >= 0) x else -x Correcto: def abs(x: Double) = if (x >= 0) x else -x

14 Expresiones if anidadas def entre(x: Double, x1: Double, x2: Double) = if (x < x1) false else if (x > x2) false else true Expresiones condicionales: match Similar al cond de Scheme var myvar = 3; myvar match { case 1 => "Uno" case 2 => "Dos" case 3 => "Tres" case 4 => "Cuatro" } El default se escribe como _ case _ => otro caso

15 Funciones recursivas El típico ejemplo de función recursiva: factorial en Scala def factorial(x: Long): Long = if (x == 0) 1 else x * factorial(x - 1) Máximo común divisor recursivo: def gcd(x: Long, y:long): Long = if (y == 0) x else gcd(y, x % y) Listas La clase List de Scala permite definir listas Al igual que Scheme son inmutables y tienen una estructura recursiva A diferencia de Scheme son estrictamente tipeadas val fruit = List("apples", "oranges", "pears") val nums = List(1, 2, 3, 4) val diag3 = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1)) val empty = List()

16 Operador cons Funciona igual que en Scheme, produce una nueva lista añadiendo un nuevo elemento a su cabeza Se define con 4 puntos :: val dostres = List(2, 3) val undostres = 1 :: dostres La lista vacía se define con el identificador Nil val unodostres = 1 :: 2 :: 3 :: Nil val fruit = "apples" :: ("oranges" :: ("pears" :: Nil)) val nums = 1 :: (2 :: (3 :: (4 :: Nil))) val diag3 = (1::(0::(0::Nil))):: (0 :: (1 :: (0 :: Nil))) :: (0 :: (0 :: (1 :: Nil))) :: Nil val empty = Nil val nums = 1::2::3::4::Nil Operaciones básicas sobre listas head: devuelve el primer elemento de la lista tail: devuelve el resto de la lista isempty: predicado que comprueba si la lista es vacía ::: operador similar a append que concatena dos listas

17 Funciones sobre listas Con las operaciones previas se pueden definir funciones similares a las que vimos en Scheme Inserción en una lista ordenada: Funciones sobre listas Con las operaciones previas se pueden definir funciones similares a las que vimos en Scheme Inserción en una lista ordenada: def insert(x: Int, lista: List[Int]) : List[Int] = if (lista.isempty) x :: Nil else if (x < lista.head) x :: lista else lista.head :: insert(x, lista.tail)

18 Tema 6: Programación funcional en Scala Sesión 19: Programación funcional en Scala (3) Referencias Programming in Scala. Martin Odersky, Lex Spoon, Bil Venners. Ed. Artima. Programming Scala. Dean Wampler, Alex Payne. Ed. O'Reilly. Scala by Example. Martin Odersky. November A Scala Tutorial for Java programmers. Michel Schinz, Philipp Haller. November The Scala Language Specification. Martin Odersky. November 2010.

19 Funciones sobre listas Con las operaciones previas se pueden definir funciones similares a las que vimos en Scheme Inserción en una lista ordenada: Ordenación de una lista: Funciones sobre listas Con las operaciones previas se pueden definir funciones similares a las que vimos en Scheme Inserción en una lista ordenada: def insert(x: Int, lista: List[Int]) : List[Int] = if (lista.isempty) x :: Nil else if (x < lista.head) x :: lista else lista.head :: insert(x, lista.tail) Ordenación de una lista:

20 Funciones sobre listas Con las operaciones previas se pueden definir funciones similares a las que vimos en Scheme Inserción en una lista ordenada: def insert(x: Int, lista: List[Int]) : List[Int] = if (lista.isempty) x :: Nil else if (x < lista.head) x :: lista else lista.head :: insert(x, lista.tail) Ordenación de una lista: def sort(lista: List[Int]): List[Int] = if (lista.isempty) Nil else insert(lista.head, sort(lista.tail)) Funciones sobre listas Reverse-list:

21 Funciones sobre listas Reverse-list: def reverse(l: List[Int]) : List[Int] = if (l == Nil) l else reverse(l.tail) ::: List(l.head) Cadenas El tipo de Scala es String y se convierte en la clase de Java java.lang.string Al igual que las listas son inmutables Concatenación con el operador + "hola" + "adios" --> "holaadios" Funciones head, tail, charat "hola".head --> h "hola".tail -->"ola" "hola".charat(0) --> 'h'

22 Tuplas Scala permite construir tuplas de n elementos de distinto tipo Es un tipo también inmutable La forma de definir una tupla de n tipos es: (tipo1, tipo2,..., tipon) Métodos de acceso al elemento de la tupla._1,._2, Ejemplo con una tupla de tres elementos: val mitupla = (99, "Hola", true) println(mitupla._1) println(mitupla._2) println(mitupla._3) Tuplas Muy útiles para funciones que tienen que devolver más de un elemento:

23 Tuplas Muy útiles para funciones que tienen que devolver más de un elemento: def sumacadenas(s1: String, s2: String): (String, Int) = (s1+s2, s1.length+s2.length) Ámbito de variables Una vez definida una variable en un ámbito no podemos volver a definirla Sería un error el siguiente script: val a = 1 val a = 2 // error println(a) Sí es posible hacerlo en el intérprete, porque cada evaluación de una expresión crea una nuevo ámbito

24 Ámbito de variables Podemos crear un ámbito interior utilizando llaves: val a = 1; { val a = 2; println(a) } println(a) Podemos utilizar funciones locales que definen su propio ámbito: def function1(x : Int) = { def function2(y: Int) = { x*y } function2(3) } function1(2) Funciones como objetos de primera clase En Scala las funciones son también objetos de primera clase Podemos: Definir variables y parámetros de tipo función Almacenar funciones en estructuras de datos como listas o arrays Construir funciones en tiempo de ejecución (closures) y devolverlas como valor de retorno de otra función

25 Ejemplo: sumatorio La diferencia con Scheme es que Scala es un lenguaje tipeado y hay que definir el tipo de la función que se pasa como parámetro La función f que se pasa como primer parámetro de sum debe recibir un entero y devolver un entero Si pasamos otro tipo de función, Scala detecta el error de tipos def square(x: Int): Int = x * x def sum(f: Int => Int, a:int, b:int): Int = if (a>b) 0 else f(a) + sum(f, a+1, b) Funciones anónimas Al igual que en Scheme con la forma especial lambda, en Scala podemos definir funciones anónimas creadas en tiempo de ejecución La función square anterior se podría definir de forma anónima como: (x: Int) => x * x Podemos definirla como parámetro de sum y no hace falta definir el tipo de las variables, porque Scala lo infiere a partir del tipo del primer parámetro: sum(x => x * x, a, b)

26 Funciones anónimas Una notación más concisa utiliza subrayados como huecos (placeholders) de los parámetros de la función: sum(_+2, a, b) Es equivalente a: sum(x => x+2, a, b) Variables de tipo función Al igual que en Scheme, podemos asignar funciones a variables: val f = (s:string) => s + adios f( hola ) Para asignar una función ya definida a una variable hay que utilizar la sintaxis de huecos (placeholders) para indicar al compilador que no tiene que aplicar la función: def suma3(a: Int, b: Int, c: Int) = a + b + c val f = suma3 _ f(1,2,3) --> 6

27 Variables de tipo función Podemos almacenar funciones en listas, pero todas las funciones deben tener el mismo perfil: def suma3(a: Int, b: Int, c: Int) = a + b + c def mult3(a: Int, b: Int, c: Int) = a * b * c val listafuncs = List(suma3 _, mult3 _) val f = listafuncs.head f(1,2,3) Variables de tipo función Ejemplo de función que toma una lista de funciones de un argumento y las aplica: def aplicalista (lista: List[(Int) => Int], x: Int): Int = if (lista.length == 1) lista.head(x) else lista.head(aplicalista(lista.tail,x)) def mas5(x: Int) = x+5 def por8(x: Int) = x*8 val l = List(mas5 _, por8 _) aplicalista(l, 10)

28 Variables de tipo función Es posible utilizar la sintaxis de los huecos para proporcionar algunos de los argumentos y dejar libres otros. Con la siguiente expresión definimos una variable de tipo función de un argumento a partir de una función anterior val g = suma3(1, _: Int, 10) Devolviendo funciones anónimas Las funciones pueden crearse y ser devueltas por otras funciones def makesumador(k: Int) = (x: Int) => x + k val f = makesumador(10) val g = makesumador(100) f(4) g(4) Cómo declararías el tipo devuelto por la función makesumador(int)?

29 Closures Al igual que en Scheme, las funciones definidas en un ámbito mantienen el acceso a ese ámbito y pueden usar los valores allí definidos. Llamamos closure a estas funciones En el ejemplo siguiente, el ámbito en el que se crea la función devuelta contiene la variable i (el argumento de makeclosure) y la variable valor x declarada con el valor 5 def makeclosure(i : Int) : Int => Int = { val x = 5 (j : Int) => i + j + x } val returnedfuncion : Int => Int = makeclosure(10) println(returnedfuncion) //=> <function> println(returnedfunction(20)) //=> 35, porque = 35