Definindo Funções Leonardo Lucena – IFRN, 2011 Adaptação das Transparências de Graham Hutton (http://www.cs.nott.ac.uk/~gmh/book.html)http://www.cs.nott.ac.uk/~gmh/book.html.

Apresentação em tema: "Definindo Funções Leonardo Lucena – IFRN, 2011 Adaptação das Transparências de Graham Hutton (http://www.cs.nott.ac.uk/~gmh/book.html)http://www.cs.nott.ac.uk/~gmh/book.html."— Transcrição da apresentação:

1 Definindo Funções Leonardo Lucena – IFRN, 2011 Adaptação das Transparências de Graham Hutton (http://www.cs.nott.ac.uk/~gmh/book.html)http://www.cs.nott.ac.uk/~gmh/book.html These slides may be used or modified for any educational purpose on a non-profit-making basis, provided that I am acknowledged as the original author.

2  Como em muitas linguagens de programação, funções podem ser definidas usando expressões condicionais. 1 // abs : Int => Int def abs(n: Int) = if (n >= 0) n else -n abs pega um inteiro n e devolve n se ele é positivo e -n caso contrário.

3  Expressões condicionais podem ser aninhadas z Em Scala, embora não seja obrigatório, é altamente recomendado que expressões condicionais tenham a parte else. z Isto evita qualquer possível problema de ambiguidade com condições aninhadas. 2 def signum (n: Int) = if (n < 0) -1 else if (n == 0) 0 else 1

4  Muitas funções têm uma definição mais clara usando casamento de padrões 3 def not(b: Boolean) = b match { case false => true case true => false } not mapeia false para true e true para false.

5  Funções geralmente podem ser definidas de várias maneiras usando casamento de padrões. Por exemplo, a função && pode ser definida de forma mais compacta por 4 def &&(a:Boolean, b:Boolean) = (a,b) match { case (true, true) => true case (true, false) => false case (false, true) => false case (false, false) => false } def &&(a:Boolean, b:Boolean) = (a,b) match { case (true, true) => true case (_, _) => false }

6  Entretanto, a seguinte definição é mais eficiente porque evita avaliar o segundo argumento se o primeiro for falso:  O símbolo sublinhado _ é um padrão coringa que casa com qualquer valor. 5 def &&(a:Boolean, b: => Boolean) = a match { case true => b case _ => false }

7  Padrões são casados em ordem.  Por exemplo, a seguinte definição sempre retorna false: 6 def &&(a:Boolean, b:Boolean) = (a,b) match { case (_, _) => false case (true, true) => true }

8  Internamente, cada lista não-vazia é construida usando repetidamente um operador (::) chamado cons que adiciona um novo elemento no início de uma lista. 7 List(1,2,3,4) Significa 1::(2::(3::(4::Nil))).

9  Funções com listas podem ser definidas usando padrões x::xs. 8 def head [T](a: List[T]) = a match { case x::xs => x } def tail [T](a: List[T]) = a match { case x::xs => xs } head e tail mapeiam listas não-vazias para seus primeiros e demais elementos.

10  Padrões x:xs só casam listas não-vazias:  Outros padrões xs qualquer lista (vazia ou não) x::y::xs lista com pelo menos 2 elementos x::_::xs lista com pelo menos 2 elementos 9 > head(List()) Error

11  Funções podem ser construidas sem nomea-las  Usamos expressões lambda para definir funções anônimas. 10 (x: Int) => x + x A função anônima pega um número x e devolve o resultado x + x.

12  Expressões Lambda podem ser usadas para dar um significado formal a funções definidas usando currying.  Por exemplo:  Significa 11 def add(x: Int)(y: Int) = x+y val add = (x: Int) => ((y: Int) => x+y)

13  Expressões Lambda são também úteis para definir funções que devolvem funções como resultado  Por exemplo:  É definido de forma mais natural como 12 def const(x : Int)(y: Int) = x def const (x: Int) = (y: Int) => x

14  Expressões lambda podem ser usadas para evitar a nomeação de funções que são referenciadas uma única vez.  Pode ser simplificado por: 13 def f(x: Int) = x*2+1 def impar(n: Int) = 1 to n-1 map f def impar(n: Int) = 1 to n-1 map (x: Int => x * 2 + 1) def impar(n: Int) = 1 to n-1 map (_ * 2 + 1)

15 1. Seja a função safetail que se comporta da mesma forma que a função tail, exceto que safetail mapeia a lista vazia para a lista vazia. Defina safetail usando: 1. uma expressão condicional; 2. casamento de padrões. 2. Dê tres definições para o operador lógico Ou (||) usando casamento de padrões. 14

16 3. Redefina a seguinte versão de (&&) usando condicionais ao invés de casamento de padrões 4. Faça o mesmo para a versão: 15 def &&(a:Boolean, b:Boolean) = (a,b) match { case (true, true) => true case (_, _) => false } def &&(a:Boolean, b: => Boolean) = a match { case true => b case _ => false }