Programación funcional en Rubí

Introducción

La programación funcional (FP) es un paradigma de programación alternativa a la tradicional (la programación estructural o imperativo y la programación orientada a objetos) inventado, como el "cálculo lambda" por Alonso Iglesia en 30 años, mucho antes de que se sabía que exactamente lo que era una computadora.

Los estudios de la Iglesia sirvió de base para el desarrollo del lenguaje de programación Lisp, y luego se abandonó casi por completo, ya que se cobró la programación imperativa los equipos que generan la base y como Pascal, C, y hoy el moderno C + + y Java.

La idea básica del cálculo lambda es un programa de computadora que se puede expresar, en lugar de un conjunto obligatorio de las instrucciones (hacer esto, hacer esto, haz aquello), con una serie de funciones cuyos parámetros son el mismo número funciones.

Un programa funcional se compone generalmente de una función que toma como entrada a otra función que lleva a otra función como entrada y así sucesivamente.

Esto significa que mientras un programa tradicional, escrito en un paradigma imperativo u objetos, consiste en una serie de comandos que actúan sobre la variable cuyo valor representa el "estado" del programa, la programación funcional en el concepto de variable no existe (No existe el concepto de "Estado") y la ejecución está a cargo de una serie de funciones que operan sobre la función constante.

El interés en los lenguajes funcionales se ha perdido con el tiempo por varias razones, sobre todo la dificultad de aprendizaje (por lo general un hombre piensa de los objetos en lugar de funciones, a menos que sea un matemático!) Y la dificultad de encontrar intérpretes o compiladores eficientes.

Ruby y FP

Hoy en día, este interés se ha despertado, sin embargo, debido a la programación funcional trae consigo una consecuencia de gran valor: no se puede conducir por definición a los errores en tiempo de ejecución. En otras palabras, en tiempo de compilación o la primera vez ni funciona o no funciona. No pueden comportarse de maneras no previstas a priori (en un programa funcional, de hecho, no existe el concepto de excepción).

Así nacieron y algunos están prosperando los lenguajes funcionales (más o menos puro, y con el apoyo más o menos para la programación tradicional), tales como: ML / OCaml , Haskell , F # .

Ruby no es un lenguaje funcional, sino que utiliza las técnicas de programación funcional que nos pueden ayudar a formular algoritmos más sintético, más potente y más eficaz. Además de eso, por lo general, más fáciles de leer.

Cada uno y mapa

La primera característica de las lenguas que apoyan de alguna manera la FP, es tener en su biblioteca funcional iteradores estándar. Por ejemplo:

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







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

Las funciones de "mapa" y "cada uno" de Ruby no son más que aplicar FP! De hecho, hay funciones que tienen otras funciones como argumentos. En Ruby, entonces, que las partes de los bloques de código entre {} o entre lo / fin de las funciones anónimas se construyen específicamente para temas de muchas funciones.

Estas funciones se denominan en la FP de orden superior, funciones, es decir que tienen tantas funciones como entrada.

En particular "mapa" actúa como una función matemática clásica y se puede leer de la siguiente manera: para cada elemento de la serie de uno a cinco, ejecutar la función: imprimir el número natural siguiente.

Que "mapa" o "asociados", para cada elemento de una colección (una matriz en Ruby diríamos nosotros) una cierta función definida en el bloque.

Lo mismo ocurriría naturalmente con:

 



 $ Elementi.each {...}

 

Cierres: Proc y lambda

Los cierres son un concepto similar a la de la función de orden superior: la capacidad de definir sustancialmente en función de variables que actúan sobre la vida en un contexto diferente al de la función (por ejemplo, las variables globales o variables de otras funciones).

En Ruby, puedo escribir un cierre con funciones anónimas que se puede definir con la Proc.new palabras clave o lambda.

He aquí un ejemplo:

 def multiplicar (multiplicador)



    



 volver lambda {| n | n multiplicador *}







 final









 per3 = multiplicación (3)









 per3.call pone (3) # => 9







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

No es exactamente evidente en este ejemplo que definir una función "multiplicar". ¿Qué de extraño esta función? Aquí simplemente no se usa ninguna variable!

El argumento no es un multiplicador variable es simplemente un marcador de posición para una función constante u otra.

Sin embargo, en la programación tradicional, me gustaría escribir:

 def multiplicar (a, b)



    



 volver a * b







 final









 pone a la multiplicación (3,3)

Como puede verse, sin embargo, definir un cierre con un "operador" que yo llamo per3, que define el comportamiento de todas las multiplicaciones "x3". Entonces yo llamo a este operador el número 3. También se puede llamar de forma recursiva! O llame, en lugar de una constante, en otra función.

En la programación tradicional, sin embargo, me veo obligado a definir de antemano el número de variables que intervienen en la operación - lo que limita la multiplicación de dos números - y, lo más importante, tengo que insertar un concepto de Estado, la asignación de memoria para dos variables que contienen los valores que se multiplican.

• <<
• 1
• 2
• >>