F#

Hablaba hoy mismo con un amigo sobre el disfrute que los nuevos descubrimientos que estamos haciendo en torno al .Net Framework de Microsoft nos están proporcionando. En concreto, le hablaba sobre mis avances con XNA, y él, en un momento determinado, me ha comentado que estaba empezando a ver código escrito en F# (F Sharp), otro de los lenguajes soportados por .Net. Me sonaba haber oído hablar del mismo, pero, ¿qué es realmente F#?

Dicho y hecho, comencé a investigar. Según dicen en el sitio oficial de F#, nos encontramos ante un lenguaje de programación mixto, basado en los paradigmas funcional e imperativo, que toma referentes de los lenguajes OCaml y C#. Así las cosas, no deja de resultar interesante disponer de un lenguaje con esas caracerísticas en nuestro framework de desarrollo preferido. La idea, claro está, es proporcionar el mejor lenguaje para la resolución de un determinado problema: un ebanista no fabrica un mueble con sólo una sierra. Usa la sierra, el escoplo o la lija en función de la tarea que está desempeñando en un momento dado. En este sentido, Microsoft ha ido incorporando al Framework distintos lenguajes que cumplían con los paradigmas más en boga de la programación: orientados a objetos, como C#, VB.Net o Delphi; dinámicos como IronPython o IronRuby; y funcional, ahora, con F#.

Sin duda, desde el mundo científico, el técnico y de las finanzas, donde la programación funcional es realmente la más práctica, y no deja espacio para indeterminaciones, se ha dado un gran paso al contar con un lenguaje de estas características integrado en el .Net Framework. Además, Microsoft ha dado un paso más, permitiendo que el lenguaje pueda ser usado en Mono, la alternativa open source y libre de la comunidad para .Net.

Por lo que he visto el lenguaje da mucho de sí, y habrá que investigarlo a fondo, pero por lo pronto dejo unas muestras de código fuente en las que se puede observar la elegancia de este lenguaje. Para ello, veremos la implementación de un clásico de las matemáticas computacionales, la sucesión de Fibonacci. Recordemos que era una sucesión infinita, en la que sus dos primeros términos eran 0 y 1, y el resto se calculaba como la suma de los dos anteriores: Xi = X(i-1)+X(i-2). Por ejemplo, los 10 primeros términos de la sucesión serían: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34...

• F#:

let rec fib n = if n < 2 then 1
else fib (n-2) + fib(n-1)

• Ruby:

x1,x2 = 0,1; 0.upto(size)
{puts x1; x1 += x2; x1,x2 = x2,x1}

• C# (2.0):

static int Fibonacci (int x)
{
    if (x <= 1)
       return 1;
    return Fibonacci (x-1) + Fibonacci (x-2);
}

• C#(3.5):

Func fib = null;
fib = n => n > 1 ? fib(n - 1) + fib(n - 2) : n;

• brainfuck:

>++++++++++>+>+[
    [+++++[>++++++++.--------<-]+<<.>>[
        [-]+>[<+>-]++++++<-
            [>+++[-]>+>+<<+>>
    ]<<<
]

La implementación en C# 3.5, usando System.Func y expresiones lambda, junto a la de F# y Ruby... ¡me encantan! El código de brainfuck lo incluyo, claro está, como una mera curiosidad sobre un lenguaje de programación esotérico, pero a la vez con un funcionamiento muy similar al de una máquina de Turing.

Y como nota final: por supuesto, en los lenguajes funcionales, la implementación de muchos problemas debe hacerse de manera recursiva (la equivalencia en programación a la recurrencia matemática), ya que no tienen mecanismos como la iteración (bucles). Esto ocurre en el ejemplo de F# y C# 3.5, lo que les da una sintaxis más cercana a las funciones matemáticas.

En LiteratePrograms.Org se pueden encontrar muchos más ejemplos de algoritmos implementados en diferentes lenguajes. Y si, como curiosidad, queremos ver una serie de benchmarks de eficiencia (en uso de recursos) de distintos lenguajes, podemos hacerlo en The Computer Languaje Benchmarks Game.