Funções de Alta Ordem, Lambda e Resolução de Exercícios

Funções de Alta Ordem

As High Order Functions, ou funções de alta ordem, são um conceito fundamental na programação funcional. Elas são funções que podem receber outras funções como parâmetros e/ou retornar funções como resultado. Esse conceito permite uma maior flexibilidade e poder de expressão na escrita de código, tornando-o mais conciso e legível.

Em linguagens de programação como JavaScript, Python e Haskell, as High Order Functions são amplamente utilizadas para manipulação de listas, filtragem de dados, mapeamento de valores e muito mais. Elas permitem que o programador trabalhe de forma mais abstrata e genérica, facilitando a reutilização de código e a implementação de padrões de design.

Vejamos alguns Exemplos:

python
Javascript

Versão sem função de alta ordem

def dobrar_lista(lista):
    resultado = []
    for x in lista:
        resultado.append(x * 2)
    return resultado

print(dobrar_lista([1, 2, 3, 4, 5]))

function dobrarLista(lista) {
  let resultado = [];
  for (let i = 0; i < lista.length; i++) {
    resultado.push(lista[i] * 2);
  }
  return resultado;
}

console.log(dobrarLista([1, 2, 3, 4, 5]));

Versão com função de alta ordem

def dobrar(x):
    return x * 2

def dobrar_lista_map(lista):
    return list(map(dobrar, lista))

print(dobrar_lista_map([1, 2, 3, 4, 5]))

function dobrar(x) {
  return x * 2;
}

function dobrarListaMap(lista) {
  return lista.map(dobrar);
}

console.log(dobrarListaMap([1, 2, 3, 4, 5]));

Funções de alta ordem em Haskell

Alguns exemplos de funções muito utilizadas em Haskell

map: Aplica uma função a todos os elementos de uma lista.

dobrar x = x * 2
map dobrar [1,2,3,4]

filter: Retorna uma lista contendo os elementos que satisfazem um predicado.

ehPar x = x mod 2 == 0
filter ehPar [1,2,3,4,5,6]

foldl : é uma função que reduz uma lista a um único valor aplicando uma função binária da esquerda para a direita. foldl (+) 0 [1,2,3,4]
foldr : é uma função que reduz uma lista a um único valor aplicando uma função binária da direita para a esquerda. foldr (+) 0 [1,2,3,4]
zipWith: é uma função que combina duas listas elemento a elemento usando uma função binária que você fornece.

multiplicar x y= x * y
zipWith (multiplicar) [1,2,3] [4,5,6]

takeWhile: é uma função que retorna elementos de uma lista enquanto eles satisfazem uma condição (predicado). Assim que um elemento não satisfaz a condição, a função para e retorna a lista acumulada até aquele ponto.

menor5 x = x < 5
takeWhile menor5 [1,2,3,6,4,2]

compose (.): O operador . combina várias funções em uma só, criando uma função que aplica uma depois da outra.

-- Duas funções simples
dobrar x = x * 2
somar3 x = x + 3

-- Composição
dobrarDepoisDeSomar3 = dobrar . somar3

Lambda Functions

A Lambda Function, ou função Lambda, é um conceito fundamental na programação funcional e em ambientes de computação em nuvem. Trata-se de uma função anônima que pode ser definida e utilizada sem a necessidade de um nome explícito

As Lambda Functions possuem algumas características marcantes. Elas são frequentemente utilizadas para operações simples, como manipulação de dados ou execução de cálculos rápidos. Além disso, essas funções podem ser passadas como argumentos para outras funções, o que as torna extremamente versáteis. Outro ponto importante é que, em muitos casos, as Lambda Functions podem ser definidas em uma única linha de código, facilitando a legibilidade e a manutenção do código.

Lambda em Pyton e Java

Python

square = lambda x: x**2  # returns a function object
print(square(5))  # Output: 25

Nestas linhas de código e utilizado a expressão lambda para a definição da expressão, o parametro x a ser utilizado, e a função vinculada a ele

Java

System.out.println("Imprime todos os elementos da lista!");
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
list.forEach(n -> System.out.println(n));

Neste caso a expressão lambda pode ser usada para imprimir varios elementos em uma lista

Exemplos em Haskell

Uma lambda é uma função anônima, ou seja, você define a função direto no lugar, sem precisar dar nome a ela.

A sintaxe básica é:

\lista_de_parametros -> expressao

\ : indica que é uma função lambda
lista_de_parametros : os parâmetros que a função recebe (como em funções normais)
-> : separa os parâmetros do corpo da função
expressao : o que a função retorna

Exemplo de soma

Função normal:

add :: Int -> Int -> Int
add x y = x + y

Mesma função usando lambda:

\x y -> x + y

Pode ser utilizado de maneira mais simplificada usando (+)

Isso é exemplificado retomando uma expressão vista anteriormente:

menor5 x = x < 5
takeWhile menor5 [1,2,3,6,4,2]

Utilizando lambda pode ser simplificado para:

takeWhile (\x -> x < 5) [1,2,3,6,4,2]

ou, simplicando ainda mais:

takeWhile (<5) [1,2,3,6,4,2]

Exércicios Práticos

Foi escolhido 3 exercícios dos propostos na 3º aula para tanto exemplificação dos assuntos acima como explicação geral sobre o paradigma funcional

Use a função elem para implementar uma função isVowel2 :: Char -> Bool que verifique se um caracter é uma vogal, tanto maiúscula como minúscula.

Código utilizado:

isVowel2 :: Char -> Bool
isVowel2 x = x `elem` "aeiouAEIOU"

Primeiro é associado um nome a função e depois ao tipo que ela recebe(char) e "retorna"(bool), é utilizada a função elem que varre a lista a sua direita procurando o caracter passado como parametro na esquerda

Escreva uma função onlyBetween60and80 que receba uma lista de números e retorne somente os que estiverem entre 60 e 80

Código utilizado:

between60and80 :: Int -> Bool
between60and80 int = int>=60 && int<=80

onlyBetween60and80 :: [Int] -> [Int]
onlyBetween60and80 listaInt = filter between60and80 listaInt

É feita uma função auxiliar que verifica número por número, e depois está função é usada pela função de alta ordem filter que utiliza-a como parâmetro para filtrar a lista

Note que esta função pode ser simplificada utilizando lambda, como foi visto:

onlyBetween60and80 :: [Int] -> [Int]
onlyBetween60and80 listaInt = filter (\x -> x>=60 && x<=80) listaInt

Crie uma função countSpaces que receba uma string e retorne o número de espaços nela contidos.

Código utilizado:

identifySpaces :: Char -> Bool
identifySpaces char = char == ' '

countSpaces :: String -> Int
countSpaces string = length(filter identifySpaces string)

É feita uma função auxiliar identifySpaces, ela recebe um character e verifica se é um espaço, essa função é utilizada pelo filter na string passada como argumento, que retorna uma lista com os valores que cumprem o requisito, neste caso [' ',' ']. Esta lista retornada é utilizada pelo length, que retorna o tamanho dela

Note que como no exercício anterior, também é possível utilizar a função lambda:

countSpaces :: String -> Int
countSpaces string = length(filter (\x -> x == ' ') string)

Em Haskell, os próprios operadores são funções, então pode ser feito uma simplificação ainda maior assim:

countSpaces :: String -> Int
countSpaces string = length(filter ( == ' ') string)

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
gifs		gifs
README.md		README.md

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Repository files navigation

Funções de Alta Ordem, Lambda e Resolução de Exercícios