En "Funciones de Lista I" intencionalmente incluí solamente las funciones que no toman otra función como argumento. De las que usan otra funciòn hay dos casos muy importantes, que son el bloque de construcciòn básico de muchas funciones más complicadas.

La primera es el mapa, del que existe la forma más general fmap pero normalmente se usa simplemente map, que es la que opera sobre listas. La diferencia está en la declaración de tipo:

Prelude> :t fmap
fmap :: (Functor f) => (a -> b) -> f a -> f b

Importante: muchos de los ejemplos a continuación no finalizan nunca (intentan mostrar una lista infinita o su último elemento). Para regresar al intérprete hace falta interrumpir la ejecución presionando ^C (las teclas Ctrl y c al mismo tiempo).

Las siguientes operaciones están definidas en la biblioteca estándar de Haskell para trabajar con listas:

(++) concatena dos listas:

Prelude> [1..10]
[1,2,3,4,5,6,7,8,9,10]
Prelude> [100..110]
[100,101,102,103,104,105,106,107,108,109,110]
Prelude> [1..10] ++ [100..110]

Cuando se quiere aplicar la misma operación a más de un valor se puede utilizar una lista para almacenar los diferentes argumentos, y también el resultado.

La forma inmediata de construir una lista es por medio de otra lista, que puede ser la lista vacía [], y el operador (:):

Prelude> :t []
[] :: [a]
Prelude> :t (:)
(:) :: a -> [a] -> [a]
Prelude> 7:[]
[7]
Prelude> 3:it
[3,7]

Una vez más, it representa al resultado inmediatamente anterior.    [[Seguir leyendo]]

Las funciones lógicas son las que toman cualquier tipo o cantidad de argumentos y regresan un Bool. No necesitan que los argumentos sean números; solamente hace falta que el tipo de los argumentos sea instancia de la clase de tipos Ord (i.e. que exista algún orden definido para ese tipo).

Todos los números "convencionales" (eso es, todos los tipos de datos que son instancia de la clase de tipos Num) son instancia de Ord, pero no son los únicos. (Más detalles sobre clases de tipos en una entrega posterior). Por ejemplo, los caracteres también tienen orden:

     [[Seguir leyendo]]

No todas las funciones aritméticas en la biblioteca base de Haskell son operadores; la mayoría no lo son. Se cuenta con las siguientes funciones.

Para cualquier número:

negate le cambia el signo al número.

Prelude> negate 7
-7
Prelude> negate (-7)
7
Prelude> negate.negate $ 7
7

abs es valor absoluto:

Prelude> abs 7
7
Prelude> abs (-7)
7

signum produce un 1 "multiplicable" con el signo del argumento.

     [[Seguir leyendo]]

Haskell interpretado, por ejemplo con ghci, puede ser utilizado como calculadora. Se pueden utilizar los operadores '+', '-', '*', '/', '**', '^' y '^^'. En realidad no son operadores; son funciones que toman dos argumentos, y al ponerlos entre paréntesis se pueden emplear con la sintaxis usual.

Prelude> 2 + 3
5
Prelude> (+) 2 3
5
Prelude> (7-4)*6
18
Prelude> (*) ((-) 7 4) 6
18

El operador '/' solamente opera sobre valores fraccionarios, como se puede ver en su declaración de tipo:

     [[Seguir leyendo]]

¿Cual es la diferencia entre Haskell y C?

El modelo de cómputo.

En C el modelo tiene la siguiente "forma":

{-
      |          INICIO
      |          INST1
      |     |--> INST2
      |     |    INST3
      |     |    INST4
      |     ---- INST5
      |          INST6
      v          FIN
-}

Todas las instrucciones van de arriba hacia abajo, ocasionalmente saltando de regreso.

En Haskell es más del tipo:

{-
--------------------
|     /----------- |
|     |  /-----\ | |
|     |  |B  D | | |