Haskell e Funções de Primeira Classe: Um Guia com BDD

Rodolfo Peixoto

Rodolfo Peixoto

— 2 min read
Haskell e Funções de Primeira Classe: Um Guia com BDD
Photo by Albert S / Unsplash

O Haskell é uma linguagem de programação funcional que trata funções como cidadãos de primeira classe. Isso significa que as funções no Haskell podem ser usadas da mesma forma que qualquer outro valor. Vamos explorar o que isso implica e como você pode aproveitar essas características para escrever código mais expressivo e poderoso.

Definição de Funções de Primeira Classe

Em Haskell, funções de primeira classe são aquelas que podem ser:

  • Passadas como argumentos para outras funções.
  • Retornadas como valores de outras funções.
  • Atribuídas a variáveis.
  • Armazenadas em estruturas de dados.

Essa flexibilidade permite que os programadores escrevam código mais abstrato e reutilizável.

Usando Funções como Argumentos

Uma das maneiras mais comuns de usar funções de primeira classe no Haskell é passá-las como argumentos para outras funções. Isso é frequentemente visto em funções de ordem superior, como map e filter.

Exemplo:

duplicar :: Int -> Int
duplicar x = x * 2

aplicarLista :: (a -> b) -> [a] -> [b]
aplicarLista f lista = map f lista

main = print $ aplicarLista duplicar [1, 2, 3, 4]
-- Saída: [2, 4, 6, 8]

Abstraindo Cálculos Fora de uma Função

A abstração de cálculos permite que você separe a lógica específica de um problema da lógica geral. Isso é útil para criar funções mais genéricas que podem ser adaptadas para diferentes situações.

Exemplo:

aplicarOperacao :: (a -> b) -> a -> b
aplicarOperacao operacao valor = operacao valor

incrementar :: Int -> Int
incrementar x = x + 1

main = print $ aplicarOperacao incrementar 5
-- Saída: 6

Retornando Funções como Valores

No Haskell, você também pode criar funções que retornam outras funções. Isso é útil para criar funções configuráveis ou para adiar a execução de uma operação.

Exemplo:

criarMultiplicador :: Int -> (Int -> Int)
criarMultiplicador n = (\x -> n * x)

multiplicadorDeTres :: Int -> Int
multiplicadorDeTres = criarMultiplicador 3

main = print $ multiplicadorDeTres 5
-- Saída: 15

Exemplo prático

Passo 1: Definir o Comportamento

Primeiro, vamos definir o comportamento que esperamos da nossa função. Vamos criar uma função que recebe outra função (uma operação) e um número, e aplica essa operação ao número.

Passo 2: Escrever o Teste

Antes de implementar a função, vamos escrever um teste para ela. Usaremos o framework Hspec para escrever nossos testes em um estilo BDD.

Crie um arquivo de teste, por exemplo, test/Spec.hs:

import Test.Hspec
import Lib (aplicarOperacao)

main :: IO ()
main = hspec $ do
  describe "aplicarOperacao" $ do
    it "aplica uma função de multiplicação a um número" $ do
      aplicarOperacao (*2) 5 `shouldBe` 10
    it "aplica uma função de adição a um número" $ do
      aplicarOperacao (+3) 5 `shouldBe` 8

Passo 3: Implementar a Função

Agora, vamos implementar a função em src/Lib.hs:

module Lib
  ( aplicarOperacao
  ) where

aplicarOperacao :: (Int -> Int) -> Int -> Int
aplicarOperacao f n = f n

Neste código, aplicarOperacao é uma função de primeira classe que recebe uma função f e um inteiro n, e aplica f a n.

Passo 4: Executar os Testes

Execute os testes para garantir que a implementação atenda ao comportamento esperado:

stack test

Se os testes passarem, significa que a função atende aos requisitos especificados.

O tratamento de funções como cidadãos de primeira classe no Haskell abre um mundo de possibilidades para abstração e reutilização de código. Essa abordagem permite que os programadores escrevam códigos mais concisos, expressivos e flexíveis, aproveitando ao máximo o paradigma da programação funcional. Com a prática, você começará a ver como esses conceitos podem ser aplicados para resolver problemas complexos de maneiras elegantes e eficientes.

Read more