“El cálculo lambda es un sistema formal diseñado para investigar la definición de función, la noción de aplicación de funciones y la recursión. Fue introducido por Alonzo Church y Stephen Kleene en la década de 1930; Church usó el cálculo lambda en 1936 para resolver el Entscheidungsproblem. Puede ser usado para definir de manera limpia y precisa qué es una "función computable". El interrogante de si dos expresiones del lambda cálculo son equivalentes no puede ser resuelto por un algoritmo general. Esta fue la primera pregunta, incluso antes que el problema de la parada, para el cual la indecidibilidad fue probada. El cálculo lambda tiene una gran influencia sobre los lenguajes funcionales, como Lisp, ML y Haskell.
Se puede considerar al cálculo lambda como el más pequeño lenguaje universal de programación. Consiste en una regla de transformación simple (sustitución de variables) y un esquema simple para definir funciones.
El cálculo lambda es universal porque cualquier función computable puede ser expresada y evaluada a través de él. Por lo tanto, es equivalente a las máquinas de Turing. Sin embargo, el cálculo lambda no hace énfasis en el uso de reglas de transformación y no considera las máquinas reales que pueden implementarlo. Se trata de una propuesta más cercana al software que al hardware.”[ http://es.wikipedia.org/wiki/C%C3%A1lculo_Lambda]

Lambda es el feacture con el cual podremos ejecutar funciones anónimas. Es decir funciones sin ningún nombre.
La sintaxis de lambda en python es:

lambda :

lambda <aParameterList> : <a Python expression using the parameters>

por ejemplo

lambda x: x+1

Los ejemplos de la entrada de programación funcional con lambda quedarían:

lambda y map:

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : map_lambda.py

lt = range(5)
print lt
print map (lambda x:x + 1,lt)
print lt

lambda y filter:

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : filter_lambda.py

lt = range(5)
print lt
print map (lambda x:x in (1,3,6),lt) #como ya sabemos manejar map ;-).
print filter (lambda x:x in (1,3,6),lt)
print lt

lambda y reduce:

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : reduce.py

lt = range(5)
lts = ["hola ","como ","estas."]

print " lt -> %s"%lt
print " lts -> %s" %lts 

print " reduce lt  -> %s" %reduce (lambda x,y : x+y,lt)
print " reduce lts -> %s" %reduce (lambda x,y : x+y,lts)

-

Los programas escritos en un lenguaje funcional están constituidos únicamente por definiciones de funciones, entendiendo éstas no como subprogramas clásicos de un lenguaje imperativo, sino como funciones puramente matemáticas, en las que se verifican ciertas propiedades como la transparencia referencial (el significado de una expresión depende únicamente del significado de sus subexpresiones), y por tanto, la carencia total de efectos laterales.
Otras características propias de estos lenguajes son la no existencia de asignaciones de variables y la falta de construcciones estructuradas como la secuencia o la iteración (lo que obliga en la práctica a que todas las repeticiones de instrucciones se lleven a cabo por medio de funciones recursivas).
Existen dos grandes categorías de lenguajes funcionales: los funcionales puros y los híbridos. La diferencia entre ambos estriba en que los lenguajes funcionales híbridos son menos dogmáticos que los puros, al admitir conceptos tomados de los lenguajes imperativos, como las secuencias de instrucciones o la asignación de variables. En contraste, los lenguajes funcionales puros tienen una mayor potencia expresiva, conservando a la vez su transparencia referencial, algo que no se cumple siempre con un lenguaje funcional híbrido.”
[http://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional]

Python nos facilita un conjunto de feature  que nos permite darle un enfoque funcional a nuestra programación.  Estos feacture son:

• map
• filter
• reduce
• lambda
• listas por comprensión

Map:

La función “map” es una función de orden superior, que recibe en su primer parámetro una función fx y en su segundo parámetro una lista lt. Y lo que hará simplemente es aplicar la función fx a los elementos de la lista lt.
Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : map.py

lt = range(5)
def fx(x):
    return x + 1

print lt
print map (fx,lt)
print lt

Filter:

La función “filter” es una función de orden superior, que recibe en su primer parámetro una función fx  que retorne true o false y en su segundo parámetro una lista lt. Y lo que hará simplemente es aplicar la función fx a los elementos de la lista lt y retornar una lista con todos los elementos que dieron trae.

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : filter.py

lt = range(5)
def fx(x):
    return x in (1,3,6)

print lt
print map (fx,lt) #como ya sabemos manejar map
print filter (fx,lt)
print lt

Reduce:

La función “reduce” es una función de orden superior, que recibe en su primer parámetro una función fx y una lista lt. Pero su funcionamiento es menos evidente que "map" y "filter", ya que lo que devuelve es un solo elemento. Para verlo mas claro veamos el ejemplo.

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : reduce.py

lt = range(5)
lts = ["hola ","como ","estas."]
def sumatoria(x,y):
    return x+y

print " lt -> %s"%lt
print " lts -> %s" %lts 

print " reduce lt  -> %s" %reduce (sumatoria,lt)
print " reduce lts -> %s" %reduce (sumatoria,lts)

print " lt -> %s"%lt
print " lts -> %s" %lts

En las próximas entradas explicaremos listas por comprensión  y lambda.

Erlang es un lenguaje de alto nivel, funcional, de asignación única y dinámico, como Ruby. Ha sido desarrollado en los laboratorios de Ericsson partiendo de tres premisas fundamentales: tolerancia a fallos, concurrencia y sencillez. Las aplicaciones Erlang pueden correr sobre una máquina virtual o ser traducidas a código nativo gracias a un compilador de alto rendimiento llamado, irónicamente, HiPE.

A pesar de su origen, desde 1998 tanto la implementación del lenguaje como el conjunto de bibliotecas OTP son libres bajo la licencia EPL.

Total, que tenemos una plataforma peculiar cuya liberación cumple diez años. ¿Por qué es especial?

Pues por muchos motivos. Pero la expectación creada alrededor de Erlang tiene poco que ver con el lenguaje en si. Al fin y al cabo, hemos tenido una década para evaluarlo. Lo verdaderamente importante es el momento tecnológico que estamos viviendo. El paralelismo es ya el modelo indiscutible para alcanzar el máximo rendimiento, la guerra de los gigahertzios hace tiempo que terminó y la nueva guerra, la de los núcleos, está comenzando.

El soporte a la programación concurrente en los lenguajes tradicionales sigue siendo primitivo, muy propenso a errores. En este campo, Erlang es el rey. Puede crear y manejar cientos de miles de procesos sin despeinarse, incluso millones, evitándole al programador dolores de cabeza. El mismo lenguaje evita un montón de fallos gracias a la evaluación estricta o la asignación única de variables. Y si algo falla, ¡no hay problema! Erlang permite el cambio en caliente del código.

El lenguaje no viene solo. Trae bajo el brazo las ya mencionadas bibliotecas OTP (Open Telecom Platform), una metodología de programación (programación orientada a concurrencia), guías de diseño y patrones. Todo está probado y corriendo. De hecho, es muy probable que si realizas una llamada a través de tu teléfono móvil, alguno de los componentes que la harán posible esté construido sobre Erlang.

Más de uno se preguntará por qué coño no estamos todos alabando al dios Erlang y programando aplicaciones en este lenguaje como locos. Bueno, digamos que por muy bueno que sea, tiene algunas peculiaridades insalvables.

Para empezar, nos ha costado más de diez años adoptar el paradigma de objetos y no existe una disposición clara a cambiar de nuevo. Hemos pasado de los lenguajes estructurados a los orientados a objetos con sumo cuidado. Una muestra de ello es que C++ es casi una extensión de C y Java está inspirado en C++. ¿Y las metodologías? ¿Tendríamos que adaptar las herramientas de ingeniería de software?

Erlang da miedo porque no está respaldado por un paradigma y un lenguaje generalistas. Java llegó con la vitola de ser un C++ mejorado, lo cual demostró tener mucho peso en la comunidad de programadores. Era más sencillo, menos propenso a errores y tenía una extensísima biblioteca de clases. Sin embargo, ¿podríamos vender un Scheme mejorado? ¿Un Lisp mejorado? No es plausible. La industria está introduciendo lentamente los lenguajes funcionales como complemento de otros, como Linq, y las instituciones educativas ya les han hecho un hueco. A mí me enseñaron Caml, por ejemplo.

Y es que ya no estamos hablando de evolucionar desde un lenguaje estructurado a uno orientado a objetos. Este paso es mucho mayor. Hablamos de la enorme dificultad de cambiar los lenguajes procedimentales por lenguajes declarativos, lo que es paradójico pues un lenguaje declarativo debería tener una sintaxis más natural que uno procedimental.

Sí y no. Los que llevamos unos añitos en esto ya nos hemos adaptado a la máquina. Suena fuerte, ¿verdad? Modelamos en alto nivel y programamos en bajo nivel. Por muchas filigranas que tengan los lenguajes, por mucho que se haya escrito sobre esa facilidad a la hora de proyectar un objeto sobre algo del mundo real, todavía estamos obligados a pensar en qué queremos hacer y cómo queremos adaptar esa idea al modo de trabajar de la máquina.

Y resulta que los lenguajes funcionales no hacen eso. Intenta describir un proceso tradicional con funciones matemáticas y entenderás de qué hablo.

Pero no es tan complicado como parece. Las aplicaciones construidas con lenguajes funcionales suelen tener un código más limpio y elegante... Pero diferente. Y eso, claro está, es un hándicap.

Añadamos la orientación a concurrencia de Erlang y ya la hemos liado. Hay gente que se hace la picha un lío hasta que se da cuenta de que la primera A de Ajax es de asíncrono, ¡imaginaos qué ocurriría con una operación que cree dos docenas de procesos! Ojo, el lenguaje que nos ocupa hace que todo lo referente a la creación, destrucción, manejo y comunicación entre procesos sea insultantemente sencillo. Pero sigue siendo diferente.

Entonces, ¿a qué viene el título? ¿Por qué empezar poniendo los dientes largos a todo el mundo para caer en una aparente decepción? Bueno, Erlang tiene ahora mismo un nicho de mercado muy definido y casi intocable en aplicaciones destinadas a concurrencia o alta disponibilidad. Simplemente, es mejor que la competencia, así que podemos predecir una larga vida útil. Y si mañana alguien piensa que sería interesante incorporar al negocio un lenguaje que evite muchos de los errores de programación típicos y mejore la productividad y el rendimiento en los nuevos entornos multinúcleo, a costa de reciclarse en cuatro días, pues quién sabe, quizá lo que hoy es todavía una curiosidad alcance un buen lugar en el mercado.

Sea como fuere, estará ahí muchos, muchos años, tras el funcionamiento de tu teléfono, tu televisión o el último satélite lanzado al espacio.

NixOS pretende trasladar este concepto a las distribuciones de GNU/Linux. De entrada no me parece un sistema que cualquier usuario pueda utilizar. Estamos acostumbrados a la imperatividad, a ejecutar una aplicación y suponer el resultado.

Un sistema funcional sería más rígido aunque también más elegante y tolerante a fallos.

Ahora toca leerse el artículo técnico y pensar hasta dónde puede llegar.

Con la próxima llegada del examen de "Programación Funcional", tengo la necesidad, aunque a pequeña escala, de usar ese magnífico, moderno y completo lenguaje que es Haskell. Hasta ayer no quería complicarme la vida y directamente ejecutaba el "famoso" Winhugs, vía Parallels y Win XP. Pero me estaba hartando de tener que cepillarme la mitad de la batería de "mi querido MacBook Pro" cada vez que tenga que probar cualquier "caquiPrograma" de cualquier ejercicio; eso y el "perreo" que me entra en el cuerpo en época de exámenes... Costar no cuesta mucho, pero lo cierto es que instalarlo en MacOS X, de forma nativa no es tan fácil como de hecho lo es en Windows, esto lo tengo que reconocer, y que además las instrucciones que hay para Mac en la página oficial de Hugs están un poco desactualizadas, así que explicaré como hacerlo de manera rápida y sencilla en Leopard.

Lo primero que tenemos que hacer es instalarnos las "Developer Tools", estas herramientas de desarrollo ocupan alrededor de 1GB, se encuentran en el DVD de instalación del Mac, o el de Leopard si como yo lo habéis instalado luego. También se puede descargar de aquí.Una vez instaladas las "Tools" procedemos a instalar los "Darwin Ports", descargamos un pequeño paquete de instalación que nos instala en unos minutos dichos puertos. Cuando acabemos, abrimos una ventana de terminal y escribimos los siguiente:

% sudo port -d selfupdate
Password:

Cuando nos pide password, introducimos la contraseña del administrador del Mac donde lo estemos haciendo. Una vez hecho esto, de nuevo en Terminal, escribimos lo siguiente, eso sí, con la conexión a Internet activa, pues descargara los paquetes que necesite para proceder a la instalación:

% cd /opt/local/bin/
% sudo port install hugs98
Password:

Aquí es donde el manual que yo seguí estaba el error, pues la ruta donde aparece el ejecutable "port" es la que he puesto arriba. Tardara un poco, por las descargas y demás, no hay que cerrar la ventana de terminal hasta que no acabe. Una vez termine, listo, ya estaría instalado.Lo siguiente que podemos hacer, si queremos automatizar un poco la apertura del Hugs, es crearnos un AppleScript, para ello abrimos el "Editor de Scripts", y en la ventana que aparece escribimos lo siguiente:


tell application "Terminal"
do script "/opt/local/bin/hugs"
end tell

No sé que pasa con las comillas que las cambia por tipográficas, si hacéis copy paste cambiad las comillas por las de encima del 2 ;)

Guardamos por fin el script, como aplicación, y ahora sí que ya está, cada vez que ejecutéis este script se os abrirá una ventana de terminal con el Hugs activo.

Vía: Hugs98 en Darwin Ports