puras um ou mais apenas mesmos

Transcrição

1

2 Funções Relembrando um dos objetivos do paradigma de programação funcional: Escrever funções puras Na prática, uma função pura apresenta as seguintes características: Possui um ou mais parâmetros; Realiza cálculos utilizando apenas os parâmetros recebidos; Retorna um valor; Sempre retorna o mesmo valor para os mesmos parâmetros de entrada; Não utiliza ou modifica dados fora da função (efeito colateral); Não é afetada por alterações de dados que ocorrem fora da função (idem).

3 Funções Funções puras Equivalente às funções definidas na matemática. São funções sem estado (stateless). Facilitam a execução de programas concorrentes. Entretanto,... É difícil programar funções que não alteram estado. Precisamos ler arquivos, consultar bancos de dados, imprimir o resultado na console, etc.

4 Funções Em Scala, funções possuem equivalência com a definição de um método. A definição pode ocorrer em qualquer parte do código. Sintaxe geral: def <nome>(<parâmetro>:<tipo>[,...]):<tipo>=<expressão>

5 Funções Exemplos de definições de funções def multiplica(x: Int, y: Int): Int = { x * y } var m = multiplica(5,10) //retorna 50 O corpo da função é composto por uma ou mais expressões. A última linha executada denota o retorno da função.

6 Funções Exemplos de definições de funções def max(x: Int, y: Int): Int = { if (x > y) x else y } OU // se a função possui apenas um comando def max2(x: Int, y: Int) = if (x > y) x else y É opcional a declaração do tipo de retorno da função (inferência de tipos)

7 Funções Observação importante Na definição de funções recursivas é obrigatória a definição do tipo de função. Exemplo: def potencia(x: Int, n: Int): Long = { if (n >= 1) x * potencia(x, n-1) else 1 }

8 Funções Funções podem ser aninhadas Exemplo def E(x: Float) = { def F(y: Float) = x + y F(2*x) }... println(e(5)) > 15.0

9 Funções Alguns cuidados com funções aninhadas O parâmetro y não é visível no corpo da função E. Visível apenas dentro de F! def E(x: Float) = { def F(y: Float) = x + y F(2*x) }

10 Funções Alguns cuidados com funções aninhadas O que ocorre quando temos conflito de nomes em diferentes escopos? var a: Int = 1; def P = { var b = 1; def Q = { var b = " b "; var c = 4; println(a+b+c) } Q println(a+b) } P

11 Funções Alguns cuidados com funções aninhadas Declaração de funções aninhadas com o mesmo nome 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)) }... var m = max(42, 181, 19) // retorna 181

12 Funções Procedures Funções que não possuem um valor de retorno. A última linha executada é um comando e não uma expressão. Retorna o tipo Unit. Exemplos: def imprimesoma(x:int, y:int) = println( Soma= +(x+y))... // Mais de uma linha, obrigatório declarar Unit def imprimesoma2(x:int, y:int):unit = { println( Primeira linha ) println( Soma= +(x+y)) }

13 Exercício em Laboratório P ª Questão (2,0 pontos): Dada a seguinte função A(m,n): válida para valores inteiros não negativos de m e n, implemente uma versão recursiva da função em Scala e mostre o resultado da execução de A(1, 2).

14 Exercício 11 Reescrever os exercícios 4 e 5, usando funções. Criar obrigatoriamente as versões recursivas dos problemas propostos.

15 Exercício 12 Escreva uma função recursiva em Scala que imprime os valores de 5 a 50, sem utilizar loops.

16 Exercício 13 Escreva uma procedure em Scala para imprimir o resultado do Exercício 8.

17 Funções Mecanismos de definição de funções Em linguagens funcionais, existem normalmente dois mecanismos para definição de funções. O mecanismo tradicional (visto anteriormente) Funções anônimas (derivadas do cálculo Lambda),

18 Funções Mecanismos de definição de funções Definição formal: Seja λx.e uma expressão onde x é um identificador e E uma expressão que pode conter x (por exemplo, E -> x+1). λ é uma abstração que define uma função anônima, ou seja, a função pode ser aplicada à expressão F, denotada como (λx.e)f Como ocorre? Cada ocorrência de x em E é substituída por F e as operações restantes são realizadas.

19 Funções Exemplo de função anônima com Lambda Calcular o lambda (λx.3 x +1)4 λx é mapeado como F(4) O E da função é a expressão O valor final do lambda é 13

20 Funções Definindo funções anônimas em Scala Outro nome para funções anônimas: funções literais Exemplo: Função para incrementar o valor de uma variável var inc = (x:int) => x+1 Note que não usamos a palavra reservada def, assumindo que inc seja uma variável. x é equivalente ao identificador na expressão lambda. O operador => faz o papel do ponto na expressão. A expressão após => será avaliada sempre que um valor de função for aplicado.

21 Funções Utilizando funções literais var inc = (x:int) => x+1... var x = inc(7) println(x) > 8

22 Funções Funções literais com mais de um argumento Exemplo: Função que multiplica dois argumentos var mul = (x: Int) => (y:int) => x*y println(mul(3)(4)) > 12 mul é chamada também de função de alta ordem.

23 Funções Construção de funções de alta ordem em Scala Considere a função mul do slide anterior. mul pode receber apenas um argumento n e retorna uma função, a qual multiplica o valor por n. Exemplo: var mul = (x: Int) => (y:int) => x*y var mulnovo = mul(3) println(mulnovo(4)) > 12

24 Exercício 14 Escreva uma função anônima que calcula o máximo de três números inteiros. Atenção: evite código imperativo para o problema. Pense em uma solução funcional!

25 Funções Anônimas Relembrando as características de funções Funções podem ser aninhadas dentro de outras funções; Funções podem ser atribuídas a uma variável; Funções podem ser passadas como parâmetros de outras funções.

26 Passando funções como parâmetros var quadrado = (x:int) => x*x var somainteiroquadrado = (x:int) => (quadrado: Int => Int) => x + quadrado(x) println(somainteiroquadrado(10)(quadrado))... >110 A função somainteiroquadrado possui dois parâmetros: um inteiro e uma função

27 Passando funções como parâmetros var quadrado = (x:int) => x*x var somainteiroquadrado = (x:int) => (quadrado: Int => Int) => x + quadrado(x) var f = somainteiroquadrado(10) println(f(quadrado)) O retorno da função parcial é outra função!... >110

28 Funções como parâmetros "just-in-time" var f1 = (x:int) => x*x var f2 = (x:int) => x+1 var funcaoanonima = (x:int) => (y: Int => Int) => x + y(x) println(funcaoanonima(10)(f1)) println(funcaoanonima(10)(f2))... >110 >21 y é um parâmetro que representa uma função anônima qualquer. funcaoanonima possui um comportamento que pode mudar de acordo com os seus parâmetros!

29 Exercício em Laboratório P ª Questão (2,0 pontos): A função somaint, listada abaixo, calcula a soma dos inteiros entre a e b. A função quadrado, também listada abaixo, retorna o quadrado de um número inteiro a. Crie uma função anônima em Scala que calcula a soma dos quadrados dos inteiros entre a e b. Você deverá, obrigatoriamente, utilizar as funções somaint e quadrado na sua resposta. def somaint(a: Int, b: Int): Int = if (a > b) 0 else a + somaint(a + 1, b) def quadrado(a: Int) = a * a

30 Currificação de Funções Em Scala, podemos usar o conceito de currificação de funções Transforma uma função que recebe mais de um parâmetro em uma função que recebe uma lista de parâmetros.

31 Currificação de Funções Exemplo: f(a: Int, b: Int, c: Int) { } Invocando a função: f(a,b,c) Currificando f: f(a: Int)(b: Int)(c: Int) { } Invocando a função: f(a)(b)(c) Vantagens Legibilidade do código Possibilidade de usar funções parciais (passar apenas parte dos parâmetros)

32 Currificação de Funções Exemplo: // soma simples def soma(x: Int, y: Int) = x + y // com currificação def somacurrificada(x: Int)(y: Int) = x + y println(soma(1, 2)) println(somacurrificada(1)(2))... >3 >3

33 Currificação de Funções Exemplo: // Usando funções parciais def somacurrificada(x: Int)(y: Int) = x + y val incrementa = somacurrificada (1)_ var x = incrementa(2)... >3 Função parcial

34 Aplicação Parcial de Funções Outro Exemplo: // n é divisível por m? def ndividem(m: Int)(n: Int) = (n%m==0) val ehpar = ndividem(2)_ println(ehpar(4)) println(ehpar(5))... >true >false

35 Aplicação Parcial de Funções Mais um exemplo: def ehmultiplo(x: Int, y: Int) = y % x == 0 val f = ehmultiplo _ val x = f(7, 20) > x: Boolean = false // Aplicando funções parciais com alta ordem val ehmultiplode3 = ehmultiplo (3, _: Int) val y = ehmultiplode3(78) > y: Boolean = true

36 Recursão de calda Um tipo especial de recursão é chamado de tail recursion (recursão de calda). Ocorre quando uma função chama ela mesma na última operação do corpo da função, sem expressões adicionais. Os compiladores conseguem otimizar as chamadas de funções com recursão em calda Uso da

37 Recursão de calda Exemplo prático Fatorial recursivo (sem tail recursion) def factorial(i: BigInt): BigInt = { } if (i == 1) i else i * factorial(i - 1) A última operação é uma multiplicação. Primeiro, o compilador chama factorial e depois realiza a multiplicação. Logo, não podemos aplicar a recursão de calda.

38 Recursão de calda Alterando o código para usar recursão de calda import scala.annotation.tailrec def factorial(i: BigInt): BigInt = def fact(i: BigInt, accumulator: BigInt): BigInt = if (i == 1) accumulator else fact(i - 1, i * accumulator) fact(i, 1) } Agora, a última operação da função fact é somente a chamada recursiva.

39 Recursão de calda Outro exemplo Cálculo recursivo da potência def potencia(x: Int, n: Int): Long = { if (n >= 1) x * potencia(x, n-1) else 1 } A última operação é uma multiplicação. Não podemos aplicar a recursão de calda.

40 Recursão de calda Solução com recursão de calda import def potencia(x: Int, n: Int, t: Int = 1): Int = { } if (n < 1) t else potencia(x, n-1, x*t) Agora, a última operação da função potencia é somente a chamada recursiva.

41 Exercício 15 Escreva uma função de alta ordem que recebe um inteiro (por exemplo, y:int) e retorna uma função. A função retornada deverá receber um inteiro (por exemplo, x:int) e retornar a multiplicação de x e y.

42 Exercício 16 Crie uma função recursiva em Scala que calcula o Fatorial Duplo de um número. A definição do fatorial duplo é dada por: Obrigatoriamente, use recursão de calda em sua resposta.