Question | Answer |
Estrutura básica de uma função anonima. | (arg1 : ArgType, arg2 : ArgType, ... , argN : ArgType) => Corpo da função |
Dada uma lista a Função deve encontrar múltiplos usando currying. | def filter(xs: List[Int], p: Int => Boolean): List[Int] =
if (xs.isEmpty) xs
else if (p(xs.head)) xs.head :: filter(xs.tail, p)
else filter(xs.tail, p)
def modN(n: Int)(x: Int) = ((x % n) == 0) |
Enviar uma mensagem de uma classe para outra usando currying | def route(m:Message)(e:Endpoint) = {
e.send(m)
} |
A expressão cria uma função anônima sucessora para inteiros. | var inc = (x:Int) => x+1
var x = inc(7)-1 |
É possível definir funções anônimas com múltiplos parâmetros. | var mul = (x: Int, y: Int) => x*y
println(mul(3, 4)) |
É possível definir funções anônimas sem parâmetros. | var userDir = () => { System.getProperty("user.dir") }
println( userDir ) |
Com currying, é possível passar uma lista de parâmetros eda qual uma função será aplicada a todos os elementos | scala> def modN(n: Int)(x: Int) = ((x % n) == 0)
modN: (n: Int)(x: Int)Boolean |
Em Scala, uma função com parâmetros múltiplos pode ser misturada (curried) | scala> val mod5 = modN(5) _
mod5: (Int) => Boolean = <function1> |
Outro exemplo de uma função que usa currying para produzir múltiplos de dois números juntos. | scala> def multiply(m: Int)(n: Int): Int = m * n
multiply: (m: Int)(n: Int)Int
scala> multiply(2)(3)
res0: Int = 6 |
Mais um exemplo de função anônima associada a tipagem Int | scala> (x: Int) => x + 1
res2: (Int) => Int = <function1>
scala> res2(1)
res3: Int = 2 |
Passagem de funções anônimas, com possível salvamento em variáveis | scala> val addOne = (x: Int) => x + 1
addOne: (Int) => Int = <function1>
scala> addOne(1)
res4: Int = 2 |
Funções anônimas com maior controle através de colchetes, para melhor visualização. | def timesTwo(i: Int): Int = {
println("hello world")
i * 2
} |
Outro exemplo de função anônima passada como argumento. | scala> { i: Int =>
println("hello world")
i * 2
}
res0: (Int) => Int = <function1> |
Soma ou quadrado de inteiros usando funções anônimas | def sumInts(a: Int, b: Int): Int = sum(x => x, a, b)
def sumSquares(a: Int, b: Int): Int = sum(x => x * x, a, b) |
Um exemplo de função de soma com uso de currying. | def sum(f: Int => Int): (Int, Int) => Int = {
def sumF(a: Int, b: Int): Int =
if (a > b) 0 else f(a) + sumF(a + 1, b)
sumF
} |
Outro exemplo de transformação de uma função de somatória no formato currying | val sum: (Int, Int) => Int = _ + _
val sumCurried: Int => Int => Int = sum.curried |
União de parâmetros como formação de resultado em currying | def sum(a: Int)(b: Int) = a + b |
Funções anônimas podendo se aplicado como forma de sintetizar funções matemáticas, como módulo. | def modN(n: Int)(x: Int) = ((x % n) == 0) |
Construção do Triangulo de Pascal aplicando currying. | def pascal(c: Int, r: Int): Int =
if (c == 0 || r == 0 || c == r) 1
else pascal(c - 1, r - 1) + pascal(c, r - 1) |
Inferência de tipos são também parte das funções anônimas | val list = List(1, 2, 3, 4)
list.reduceLeft( (x, y) => x + y ) |
Aplicação da função lambda para o contexto da função anônima. | list.reduceLeft( _ + _ ) |
Aplicação de filtros para elementos de uma lista com base em funções currying | scala> l filter (_ % 5 == 0)
res4: List[Int] = List(5, 10, 15, 20, 25, 30) |
Transformando uma função de dois parâmetros em uma função curried que pode utilizar-se de vários parâmetros | scala> val partialCurryCat = curryCat("foo")(_)
partialCurryCat: (String) => java.lang.String = <function>
scala> partialCurryCat("bar")
res3: java.lang.String = foobar |
Agregando as variáveis como operadores da função generalizadas, através de currying. | def multiplier(i: Int)(factor: Int) = i * factor
val byFive = multiplier(5) _
val byTen = multiplier(10) _
scala> byFive(2)
res4: Int = 10 |