Es/Introduccion

Haskell es un lenguaje de programación para computadoras. Específicamente, es un lenguaje polimórficamente tipificado, perezoso, puramente funcional , muy diferente a la mayoría de los otros lenguajes de programación.

El lenguaje recibe su nombre en honor a Haskell Brooks Curry, por sus trabajos en lógica matemática que sirvieron como fundamento para el desarrollo de lenguajes funcionales. Haskell está basado en el cálculo lambda , por lo tanto el símbolo lambda es usado como logo.

¿Porqué usar Haskell?

Escribir programas grandes que funcionen correctamente es difícil y costoso. Mantener esos programas es aún más difícil y costoso tambien. Los lenguajes de programación funcional, tales como Haskell, pueden hacerlo mucho más fácil y económicos. Por ejemplo, un usuario nuevo quién escribió una pequeña DBMS relacional en Haskell comentó lo siguiente:

WOW! Yo básicamente escribí esto sin probarlo, sólo pensando acerca de mi programa en términos de transformaciones entre tipos. Escribí el código de ejemplos/pruebas y no tuve casi ningun error de implementación en el código!. El compilador/sistema-de-tipos es realmente realmente bueno en evitar que cometas errores de código!. Yo nunca habia tenido en mi vida un bloque de código tan grande que funcionara en el primer intento. Estoy absolutamente impresionado.

Incluso si tú no estas en una posición para usar Haskell en tus proyectos de programación, aprender Haskell puede hacerte un mejor programador en cualquier lenguaje.

Yo aprendí Haskell un par de años atrás, habiendo previamente programado en Python y (muchos) otros lenguajes. Recientemente he estado usando Python para un proyecto (la elección ha sido determinada tanto por aspectos técnicos y no-técnicos), y me doy cuenta que mi estilo de programar en Python ha sido ampliamente influenciado (para mejor, espero ;-) por mi experiencia de programación en Haskell.

Graham Klyne

Haskell te ofrece:

Un incremento substancial de productividad para el programador (Ericsson alcanzó un factor de mejoría entre 9 y 25 usando Erlang, un lenguaje de programación funcional similar a Haskell, en uno de sus experimentos en programas de telefonía).
Código más corto, claro y fácil de mantener.
Menos errores, mayor confiabilidad.
Menor diferencia semántica; entre el programador y el lenguaje.
Desarrollo de programas en menor tiempo.

Haskell es un lenguaje de un amplio espectro, conveniente para una gran variedad de aplicaciones. Específicamente para programas que necesitan ser fáciles de modificar y de mantener.

Gran parte de la vida de un programa se invierte en especificación, diseño y mantenimiento, y no en programación. Los lenguajes funcionales son magníficos para escribir especificaciones que de hecho puedan ser ejecutadas (y por lo tanto probadas y depuradas). Tal especificación es el primer prototipo del programa final.

Los programas funcionales son también relativamente fácil de mantener, porque el código es más corto, claro, y el riguroso control sobre efectos colaterales (side-effects) elimina una amplia clase de interacciones imprevisibles.

¿Qué es la programación funcional?

C, Java, Pascal, Ada, y la gran mayoría de los lenguajes, son todos imperativos. Ellos son "imperativos" en el sentido de que consisten en una secuencia de comandos, los cuales son ejecutados estrictamente uno después de otro. Haskell es un lenguaje funcional. Un programa funcional es una expresión, la cual es ejecutada mediante su evaluación.

Cualquiera que haya usado una hoja de cálculo tiene experiencia en programación funcional. En una hoja de cálculo, se especifíca el valor de cada celda en términos de los valores de otras celdas. El enfoque es que se debe computar, no en cómo debería ser computado. Por ejemplo:

No se especifica el orden en el cual las celdas deberían ser calculadas - en cambio, confiamos que la hoja de cálculo evaluará las celdas en un orden que respete sus dependencias.
No le decimos a la hoja de cálculo cómo reservar su memoria - en cambio, esperamos que nos presente un plano aparentemente infinito de celdas, y en dónde se reserve memoria sólo para esas celdas que esten usándose.
Nosotros especificamos el valor de una celda mediante una expresión (cuyas partes pueden ser evaluadas en cualquier orden), en lugar de mediante una secuencia de comandos que computen su valor.

Una interesante consecuencia de no especificar el orden de evaluación en la hoja de cálculo es que la noción de asignación no es muy útil. Después de todo, si no sabes exactamente cuando una asignación sucederá, no puedes hacer mucho uso de ella!. Esto contrasta fuertemente con programas escritos en lenguajes convencionales como C, los cuales consisten esencialmente de una secuencia cuidadosamente especificada de asginaciones, ó Java, en el cual el orden de las llamadas a métodos es crucial para el significado de un programa.

Esto se enfoca en el alto-nivel "qué" en lugar del bajo-nivel "cómo" ; esta es una característica distintiva de los lenguajes de programación funcional.

Otro lenguaje cercanamente funcional bien conocido, es el lenguaje estándar de búsqueda de base de datos SQL. Una búsqueda SQL es una expresión que involucra proyecciones, selecciones, uniones y así sucesivamente. La búsqueda especifica qué relación debería de ser computada, sin especificar cómo debería ser computada. La búsqueda puede ser evaluada en cualquier orden. Las implementaciones de SQL a menudo ejecutan extensas optimizaciones de búsqueda las cuales (junto a otros factores) calculan el mejor orden para evaluar la expresión.

¿Qué tiene de bueno la programación funcional?

Las hojas de cálculo y SQL son ambos lenguajes muy especializados. Los lenguajes de programación funcional toman las mismas ideas, y las mueven hacia el plano de una programación de propósito más general. Para tener una idea de cómo se ve un programa funcional, y la expresividad de lenguajes funcionales, mira los siguientes algoritmos de quicksort. Ambos ordenan una sequencia de números en orden ascendente usando un método estándar llamado "quicksort". El primer programa está escrito en Haskell y el segundo en C.

El programa en C describe los pasos en particular que la máquina debe llevar a cabo para ordenar -- con la mayoría del código tratando con detalles de bajo-nivel para manipular datos -- en cambio, el programa en Haskell codifica el algoritmo de ordenación en un nivel mucho más elevado, lo cual mejora la brevedad y claridad del código como resultado.

Quicksort en Haskell

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

Quicksort en C

void qsort(int a[], int lo, int hi) {
{
  int h, l, p, t;

  if (lo < hi) {
    l = lo;
    h = hi;
    p = a[hi];

    do {
      while ((l < h) && (a[l] <= p)) 
          l = l+1;
      while ((h > l) && (a[h] >= p))
          h = h-1;
      if (l < h) {
          t = a[l];
          a[l] = a[h];
          a[h] = t;
      }
    } while (l < h);

    t = a[l];
    a[l] = a[hi];
    a[hi] = t;

    qsort( a, lo, l-1 );
    qsort( a, l+1, hi );
  }
}

Exáminemos algunos de los beneficios de Haskell y de la programación funcional. Un caso más detallado para la programación funcional puede ser encontrado en

Why Functional Programming Matters by John Hughes, The Computer Journal, Vol. 32, No. 2, 1989, pp. 98 - 107. Also in: David A. Turner (ed.): Research Topics in Functional Programming, Addison-Wesley, 1990, pp. 17 - 42.

A slightly less formal essay inspired by the paper above can be found in

Why Haskell Matters originally by Sebastian Sylvan

1. Brevedad

Los programas funcionales tienden a ser mucho más concisos que sus contrapartes imperativos. Quicksort es un caso algo extremo, pero en general los programas funcionales son mucho más cortos (de dos a diez veces más cortos).

2. Fácil de entender

Los programas funcionales son a menudo más fáciles de entender. Se debería ser capaz de entender el programa anterior sin ningún conocimiento previo de tanto Haskell ó quicksort. Lo mismo ciertamente no puede ser dicho del programa en C. Toma algo de tiempo entenderlo, e incluso si se entiende, es extremadamente fácil cometer un ligero error y terminar con un programa incorrecto. Aquí una explicación detallada del quicksort en Haskell:

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

La primera línea se lee: "Cuando se ordena una lista vacía ([]), el resultado es otra lista vacía". La segunda línea se lee: "Para ordenar una lista cuyo primer elemento es nombrado x y el resto el cuál es nombrado xs, ordena los elementos de xs que sean menores que x, ordena los elementos de xs que sean mayores qué, ó igual a x, y concatena (++) los resultados, con x unido en el medio."

3. Sin errores de memoria (core dumps)

La mayoría de los lenguajes funcionales, y Haskell en particular, son fuertemente tipíficados, eliminando una amplia clase de errores fáciles de cometer en tiempo de compilación. En particular, fuertemente tipíficado significa no más errores de memoria! Simplemente no hay ningúna posibilidad de tratar un entero como un puntero, ó referenciar un puntero núlo.

4. Reúso de Código

Por supuesto, el tipíficado fuerte está disponible en muchos lenguajes imperativos, tales como Ada ó Pascal. Sin embargo, el sistema de tipo de Haskell es mucho menos restrictivo que, digamos, el de Pascal, porque usa polimorfismo.

Por ejemplo, el programa qsort en la Figura 1 no sólamente ordenará listas de enteros, sino también listas de números de punto flotante, listas de carácteres, listas de listas; verdaderamente, ordenará listas de cualquier cosa para lo cual tendría significado tener las operaciones de "menor que" y "mayor que". En contraste, la versión de C puede sólo ordenar un array de enteros, y nada más.

El polimorfismo mejora la re-usabilidad del código.

5. Conexión fuerte

Los lenguajes funcionales no-estrictos tienen otra característica poderosa: Ellos evalúan del programa sólo lo necesario para obtener la respuesta - esto se conoce cómo evaluación perezosa. Esta característica es similar a las tuberías (pipes) de UNIX. Por ejemplo, el comando Unix

grep printf Foo.c | wc

cuenta el número de líneas en el archivo Foo.c el cuál incluye la cadena printf.

El comando

grep printf Foo.c

obtiene todas las líneas que contengan la cadena "printf", mientras que el comando "wc" las cuenta. La tubería, escrita "|", toma la salida del primer comando y la pasa al segundo. Los dos comandos se ejecutan juntos, así que la salida del primero es consumida casi inmediatamente por el segundo. De esta forma, ningún archivo intermedio necesita ser creado. Se puede pensar de wc "exigiendo" líneas de grep.

Si el segundo comando sólo necesita parte de la salida del primero, entonces la ejecución del primer comando puede nunca necesitar cmpletarse. Por ejemplo

grep printf Foo.c | head 5

sólo imprime las primeras 5 líneas que contengan "printf". No existe ninguna necesidad de modificar el comando grep para hacerlo considerar que su ejecución puede ser abandonada.

Los lenguajes no-estrictos proveen exactamante esta clase de evaluación conducida-en-demanda. Las estructuras de datos son evaluadas sólo lo suficiente cómo para entregar la respuesta necesaria, y partes de ellas pueden no ser evaluadas del todo. Como en el caso de los comandos Unix, esto provee poderosas "conexiones" para combinar programas existentes. Lo que esto quiere decir, es que es posible re-usar programas , ó piezas de programas, mucho más a menudo que con una configuración imperativa. La evaluación perezosa nos permite escribir programas más modulares.

6. Abstracciones poderosas

En general, los lenguajes funcionales ofrecen nuevas formas muy poderosas para encapsular abstracciones. Una abstracción te permite definir un objeto cuyo funcionamiento interno se encuentra oculto; un procedimiento en C, por ejemplo, es una abstracción. La abstracción es la clave para construir programas modulares fáciles de mantener, tanto así, que una buena pregunta para hacerse respecto a cualquier lenguaje es "¿qué mecanismo de abstracciones ofrece?".

El mecanismo de abstracción poderoso disponible en los lenguajes funcionales son las funciones de primera clase. En Haskell una función es un ciudadano de primera clase: puede ser libremente pasada hacia otras funciones, retornada cómo el resultado de una función, almacenada en una estructura de datos, y así con cualquier otra operación. Resulta que el buen uso de las funciones de primera clase mejoran substancialmente la estructura y modularidad de muchos programas.

7. Built-in memory management

Very many sophisticated programs need to allocate dynamic memory from a heap. In C this is done with a call to malloc, followed by code to initialize the store just allocated. The programmer is responsible for returning the store to the free pool when it isn't needed any more, a notorious source of "dangling-pointer" errors. To make matters worse, malloc is fairly expensive performance-wise, so programmers often malloc a single large chunk of store, and then allocate "by hand" out of this.

Every functional language relieves the programmer of this storage management burden. Store is allocated and initialized implicitly, and recovered automatically by the garbage collector. The technology of storage allocation and garbage collection is now well developed, and the performance costs are rather slight.

When C is better

It isn't all roses, of course. The C quicksort uses an extremely ingenious technique, invented by Hoare, whereby it sorts the array in place; that is, without using any extra storage. As a result, it runs quickly, and in a small amount of memory. In contrast, the Haskell program allocates quite a lot of extra memory behind the scenes, and runs rather slower than the C program.

In effect, the C quicksort does some very ingenious storage management, trading this algorithmic complexity for a reduction in run-time storage management costs.

In applications where performance is required at any cost, or when the goal is detailed tuning of a low-level algorithm, an imperative language like C would probably be a better choice than Haskell, exactly because it provides more intimate control over the exact way in which the computation is carried out.

Functional vs imperative

But few programs require performance at any cost! After all, we all stopped writing assembly-language programs, except perhaps for key inner loops, long ago. The benefits of having a more supportive programming model (an arbitrary number of named, local variables instead of a fixed number of registers, for example) far outweigh the modest run-time costs.

Similarly, we willingly accept the costs of a virtual memory paging system, in exchange for the more supportive programming model of an infinite virtual address space. The days of explicit memory overlays are over.

Functional languages take another large step towards a higher-level programing model. Programs are easier to design, write and maintain, but the language offers the programmer less control over the machine. For most programs the result is perfectly acceptable.

What is Haskell?

Haskell is a modern, standard, non-strict, purely-functional programming language. It provides all the features sketched above, including polymorphic typing, lazy evaluation and higher-order functions. It also has an innovative type system which supports a systematic form of overloading and a module system.

It is specifically designed to handle a wide range of applications, from numerical through to symbolic. To this end, Haskell has an expressive syntax, and a rich variety of built-in data types, including arbitrary-precision integers and rationals, as well as the more conventional integer, floating-point and boolean types.

There are a number of compilers and interpreters available. All are free. First-time users may want to start with Hugs, a small, portable Haskell interpreter.

Does Anyone Use Functional Programming?

Functional programming languages are used in substantial applications. For example:

Software AG, a major German software company, market an expert system (Natural Expert) which is programmed in a functional language. Their users find it easy to develop their applications in this language, through which they gain access to an underlying database system. It all runs on an IBM mainframe.
Ericsson have developed a new functional language, Erlang, to use in their future telephony applications. They have already written 130k-line Erlang applications, and find them very much shorter and faster to develop.
Amoco ran an experiment in which they re-coded in a functional language a substantial fraction of their main oil-reservoir simulation code, a critical application. The resulting program was vastly shorter, and its production revealed a number of errors in the existing software. Amoco subsequently transcribed the functional program into ... with encouraging results.
A researcher at the MITRE corporation is using Haskell to prototype his digital signal-processing applications.
Researchers at Durham University used a functional language in a seven-year project to build LOLITA, a 30,000-line program for natural-language understanding.
Query is the query language of the O2 object-oriented database system. O2Query is probably the most sophisticated commercially-available object-oriented database query language and it is a functional language.
ICAD Inc market a CAD system for mechanical and aeronautical engineers. The language in which the engineers describe their design is functional, and it uses lazy evaluation extensively to avoid recomputing parts of the design which are not currently visible on the screen. This results in substantial performance improvements.
An incestuous example: the Glasgow Haskell compiler is written in Haskell: a 30,000-line application.

Some other examples of Haskell in practice.

Clifford Beshers, of Linspire Inc., describes their experience with Haskell, and functional programming:

Linspire, Inc. has used functional programming since its inception in 2001, beginning with extensive use of O'Caml, with a steady shift to Haskell as its implementations and libraries have matured. Hardware detection, software packaging and CGI web page generation are all areas where we have used functional programming extensively.

Haskell's feature set lets us replace much of our use of little languages (e.g., bash or awk) and two-level languages (C or C++ bound to an interpreted language), allowing for faster development, better code sharing and ultimately faster implementations. Above all, we value static type checking for minimizing runtime errors in applications that run in unknown environments and for wrapping legacy programs in strongly typed functions to ensure that we pass valid arguments.