Programación funcional (Scala, Clojure, etc.)

Visto que en el hilo de MV Coders on fire despertaron cierto interes Haskell/Lisp y derivados (y que acabé con una conversación paralela con Eisenfaust) me decido a abrir este hilo propio para el tema.

Supongo que no tendrá mucha actividad pero pretendo que quede como "cajón de sastre" de todo lo funcional a pesar de lo muy diverso de sus lenguajes (es como hacer un hilo de POO, pero por separado tendría aún menos actividad...)

Aquí en #1 pretendo recopilar pequeñas descripciones/enlaces/snippets/loquesea de cada lenguaje. Me da pereza hacer muchos así que iré poniendo poco a poco (y obviamente acepto colaboraciones.)

La idea que tengo con este thread es en primer lugar dejar de derailear threads (no es la primer vez que acabo hablando de funcional con Eisenfaust en otros hilos) y sobre todo, a ver si se anima alguien a probar la programación funcional (evangelización ftw!) Además es un buen punto de recogida de información/enlaces tanto para mí (que suelo perder todos los enlaces) como para compartir con el resto.

Programación funcional: ¿qué es?

La programación funcional (Wikipedia inglés, español) es un paradigma de programación que trata la computación como la evaluación de funciones (funciones en el sentido matemático, p.ej. f(x)), evitando estados y datos mutables. Establece su énfasis en la aplicación de funciones para la consecución de un objetivo, frente al paradigma imperativo, que enfatiza los cambios del estado interno de la computación (asignación a variables.)

Históricamente se puede considerar a la programación funcional como una evolución del cálculo lambda (de ahí que aparezcan tantas lambdas en los logos de los lenguajes funcionales, y ciertas funciones en algunos se llamen lambda.) El cálculo lambda es un sistema formal desarrollado en los años 30 por Church y Kleene para investigar la definición y aplicación de funciones y la recursividad. No cumplió realmente su objetivo como sistema de formalización, pero sí encontró un hueco en la teoría de la computación.

La mayoría de lenguajes no son puramente funcionales, si no que incorporan características del paradigma, del mismo modo que C++ no es puramente orientado a objetos y pemite programación imperativa.

- Ventajas

• Flujo de ejecución previsible

• Favorece pequeños bloques de ejecución

• Pruebas unitarias más cortas y extensivas

• Reusabilidad

• Mayor facilidad para la ejecución concurrente

- Enlaces

• Functional Languages 101: What’s All the Fuss About? (conferencia)

• Design Patterns in Dynamic Languages

• Project Euler, problemas para practicar lenguajes

Lisp y dialectos

...

- Enlaces

• QuickLisp

• Racket

• Chicken Scheme

• Practical Common Lisp

• Revised(5) Report on the Algorithmic Language Scheme

• L-99: Ninety-Nine Lisp Problems

Scala

Scala es un lenguaje de programación multi-paradigma, ya que incorpora características de programación orientada a objetos, funcional, concurrente... Soporta como plataformas Java (corre sobre la JVM) y CLR (Common Language Runtime de la plataforma .NET, aunque el soporte es menor.) Es completamente interoperable con sus plataformas: puedes llamar a código/clases/librerías Java (o .NET en CLR) desde Scala y viceversa.

El objetivo de Scala es mantener una sintaxis limpia y concisa que permita escribir código breve. Además cabe destacar que, a pesar de mantener el tipado estático (exactamente igual que Java) el compilador infiere los tipos donde es posible, por lo que la mayoría del código tiene el mismo aspecto que tendría en un lenguaje con tipado dinámico.

Otra gran característica es su extensibilidad. Es fácil crear nuevos constructos para el lenguaje que adquieren la apariencia de pertener al lenguaje en sí. Además, hacer esto no requiere de creas costosas macros si no que el flujo de extensión es prácticamente el mismo que escribir un programa. Gracias a esta extensibilidad se pueden implementar pequeños DSLs (Domain Specific Languages) dentro de Scala.

def fact(n: Int) = {
  if (n >= 2) (2 to n).reduce(_*_)
  else 1
}

def fact(n: Int): Int = {
  if (n >= 2) n*fact(n-1)
  else 1
}

def fact(n: Int) = {
  if (n >= 2) (BigInt(2) to BigInt(n)) reduce(_*_)
  else BigInt(1)
}

def fact(n: Int) = {
  if (n >= 2) (BigInt(2) to BigInt(n)).par.reduce(_*_)
  else BigInt(1)
}

def time(f: => Unit) = {
  val s = System.nanoTime
  f
  System.nanoTime - s
}

// Ahora se puede usar como time{ instruccion; instruccion2; instruccion3; ... }
// Ejemplo en intérprete:
time {
  Thread.sleep(2000)
  fact(10000)
  Thread.sleep(2000)
}
res1: Long = 4032481133

- Enlaces

• Web oficial de Scala

• FAQ oficial de Scala

• Un tour de Scala

• Learning Scala

• Simply Scala, tutorial interactivo e intérprete

• Scala IDE para Eclipse

• Effective Scala, consejos del equipo de Twitter

- Libros, documentación...

• A Scala Tutorial for Java programmers (PDF)

• Scala By Example (PDF)

• Programming in Scala (LIBRO) Este es el único libro del que puedo opinar pero es GENIAL. Comprensible, extensivo... una gozada. Escrito por el propio creador de Scala (Martin Odersky)

• Otros libros...

Clojure

Clojure (pronunciado "closur") es un lenguaje de programación funcional (híbrido) orientado a la programación multi-hilo. Es un dialecto de Lisp integrado en distintas plataformas: JVM (Java), CLR (.NET) y JavaScript, permitiendo interoperabilidad con estas. La motivación para desarrollar (otro) dialecto de Lisp viene de la necesidad de un Lisp moderno (frente a los desactualizados estándares de Common Lisp o Scheme) en simbiosis con plataformas ya establecidas y diseñado de base para la concurrencia.

Como el resto de Lisps (ver sección Lisp y dialectos más arriba) es homoicónico, es decir, no distingue entre datos y código. Su sintaxis se basa en S-expresiones (estructuras de datos basadas en listas) que son parseadas y posteriormente compiladas. Soporta sintaxis literal para listas (), vectores [], mapas {} y conjuntos #{}. Es un Lisp-1 (soporta usar funciones en variables como una función normal) pero no es compatible en código con otros dialectos. Como característica diferente al resto de Lisps implementa multimétodos, permitiendo polimorfismo estilo OOP.

Clojure favorece el desarrollo incremental en su intérpreto o REPL (read-eval-print loop) aunque también permite la ejecución de scripts y compilación a sus respectivas plataformas.

(defn square [x] (* x x))

(defn fact [n]
  (if (> n 1)
      (* n (fact (dec n)))
      1))

(defn fact [n]
  (loop [current 2 accum 1]
    (if (< current n)
        (recur (inc current) (* accum current))
        (* accum current))))

(defn fact [n] (reduce * (range 2 n)))

; El apóstrofe en *' marca la diferencia
(defn fact [n]
  (reduce *' (range 2 n)))

(javax.swing.JOptionPane/showMessageDialog nil "Hello World")

- Enlaces

• Web oficial de Clojure

• Try Clojure, tutorial interactivo e intérprete

• Learning Clojure through the REPL un (sorprendentemente educativo) viaje por Clojure a través de un log de experimentos con el REPL

• 4Clojure, puzzles estilo fill-the-gap

• Clojure-koans A set of exercises for learning Clojure

• Clojure Tutorial For the Non-Lisp Programmer

• Clojure Programming en Wikibooks

- Libros, documentación...

• Clojure Cheatsheet

• ClojureDocs

• Clojure - Functional programming for the JVM

• Clojure Series