Programação funcional em Ruby

Introdução

Programação funcionais (FP) é uma alternativa para o paradigma de programação tradicionais (programação estrutural ou imperativo e programação orientada a objetos) inventou, como o "lambda cálculo" por Alonso Church em 30 anos, bem antes de ter sido conhecido que exatamente o que era um computador.

Estudos da Igreja serviu de base para o desenvolvimento da linguagem de programação Lisp, e então eles foram quase que completamente abandonada, como alegaram a programação imperativa os computadores que gerou o básico e, como Pascal, C, e hoje o moderno C + + e Java.

A idéia básica do cálculo lambda é que um programa de computador pode ser expressa, em vez de um conjunto obrigatório de instruções (fazer isso, então faça isso, então faça isso), com uma série de funções cujos parâmetros são o mesmo número funções.

Um programa funcional é geralmente composto de uma função que toma como entrada uma outra função que recebe outra função como entrada, e assim por diante.

Isto significa que enquanto um programa tradicional, escrito em um paradigma imperativo ou objetos, consiste de uma série de comandos que atuam sobre a variável cujo valor representa o "estado" do programa, programação funcional no próprio conceito de variável não existe (Não existe o conceito de "estado") ea execução é confiada a um número de funções que operam na função constante.

O interesse em linguagens funcionais foi perdido ao longo do tempo por vários motivos, principalmente a dificuldade de aprendizagem (geralmente um homem pensa em objetos em vez de funções, a menos que ele é um matemático!) E a dificuldade em encontrar intérpretes eficiente ou compiladores.

Ruby e FP

Hoje, esse interesse foi despertado, no entanto, porque a programação funcional traz consigo uma conseqüência de muito valioso: não pode levar por definição a erros em tempo de execução. Em outras palavras, em tempo de compilação ou na primeira vez ou ele funciona ou não funciona. Não pode se comportar de maneiras não previstas a priori (em um programa funcional, de fato, não existe o conceito de exceção).

Assim nasceram e alguns estão prosperando linguagens funcionais (mais ou menos puro, e com o apoio mais ou menos para a programação tradicional), tais como: ML / OCaml , Haskell , F # .

Ruby não é uma linguagem funcional, mas utiliza técnicas de programação funcionais que podem nos ajudar a formular algoritmos mais sintético, mais potente e mais eficaz. Além disso, geralmente, mais fácil de ler.

Cada um e mapa

A primeira característica de linguagens que suportam de algum modo a FP, é de ter em sua biblioteca padrão iteradores funcional. Por exemplo:

 $ Elementos = [1,2,3,4,5]







 Elementi.map $ {| elem | puts elem} + 1

As funções de "mapa" e "cada" do Ruby não são nada mais do que aplicada FP! Na verdade, existem funções que têm outras funções como argumentos. Em Ruby, então, que as partes dos blocos de código entre {} ou entre fazer / end funções anônimas são construídas especificamente para ser temas de muitas funções.

Essas funções são chamadas de FP de alta ordem funções, ou seja, funções que levam tantas funções como entrada.

Em particular "mapa" atua como uma função matemática clássica e pode ser lido da seguinte forma: para cada elemento da série 1-5, executar a função: imprimir o próximo número natural.

Que "mapa" ou "associados", para cada elemento de uma coleção (um Array em Ruby diríamos) uma certa função definida no bloco.

A mesma coisa iria acontecer naturalmente com:

 



 $ Elementi.each {...}

 

Closures: Proc e lambda

Os fechamentos são um conceito semelhante ao da função de alta ordem: a capacidade de definir substancialmente em função de variáveis ​​que atuam sobre a vida em um contexto diferente do da função (por exemplo variáveis ​​globais ou variáveis ​​de outras funções).

Em Ruby, eu posso escrever um fechamento usando funções anônimas que podem ser definidos com a Proc.new palavras-chave ou lambda.

Aqui está um exemplo:

 def multiplicar (multiplicadores)



    



 retorno lambda {| n | n multiplicador *}







 final









 Per3 multiplicação = (3)









 per3.call puts (3) # => 9







 coloca per3.call (per8.call (2)) # => 48

Não exatamente auto-evidente neste exemplo eu definir uma função "multiplicar". O que é tão estranha esta função? Aqui eu simplesmente não usar qualquer variável!

O argumento não é um multiplicador variável é simplesmente um espaço reservado para uma função constante ou de outra.

Mas, na programação tradicional, eu escreveria:

 def multiplicar (a, b)



    



 retornar uma b *







 final









 coloca a multiplicação (3.3)

Como pode ser visto, no entanto, eu defino um fechamento usando um "operador" Eu chamo Per3, que define o comportamento de todas as multiplicações "x3". Então eu chamo este operador o número 3. Eu também posso chamá-lo de forma recursiva! Ou chamá-lo, em vez de uma constante, em outra função.

Na programação tradicional, no entanto, sou forçado a definir com antecedência o número de variáveis ​​envolvidas na transação - que limita a multiplicação de dois números - e, mais importante, eu tenho que inserir um conceito de Estado, alocando memória para duas variáveis ​​que contêm os valores a serem multiplicados.

• <<
• 1
• 2
• >>