En Haskell, usamos el comando ‘:edit’, seguido por el nombre de un fichero: Prelude> :edit nuevo; se activa el editor de texto que ocupa temporalmente el lugarde Haskell y en el escribimos la definición de la nueva función. Por ejemplo factorialDe ::Integer->Integer factorialDe n=product[1..n] Guardamos como: funcionFactorial.hs y luego cerramos el editor Volvemos a Haskell y activamos la nueva función: Prelude> load “f:\\funcionFactorial.hs” Digitamos fac 4 en: main> factorialDe 4 y obtendremos como respuesta 24

También los siguientes comandos se envían directamente al interprete.

• :load fichero(s) Permite conocer las funciones que están definidas en los ficheros especificados.
• :also fichero(s) permite añadir definiciones de otros ficheros, sin eliminar las definiciones existentes.
• :edit fichero Crear o modificar un fichero. Sin nombre, edit usa el ultimo fichero recuperado y, después de salir del procesador de textos, se carga otra vez.
• type expresion Determina el tipo de la expresión dada.
• :set ±letra Permite aplicar o eliminar algunas opciones. Activa y desactiva número de reducciones y cuanta memoria se ha usado.

• La lista vacía, se representa mediante [].
• Las listas no vacías pueden ser construidas
  • Enunciando explícitamente sus elementos, por ejemplo, [1,3,10].
  • Agregando un elemento al principio de otra lista utilizando el operador de construcción (:).

El operador (:) es asociativo a la derecha, de forma que
1: 3: 10:[] equivale a
(1:(3:(10:[]))), lista cuyo primer elemento es 1, el segundo 3 y el último 10.
El standar prelude incluye un amplio conjunto de funciones de manejo de listas.
Ejemplo: length xs devuelve el número de elementos de xs Prelude>length [1,3,10] 3

Puesto que las cadenas son representadas como listas de caracteres, todas las funciones del estándar prelude para listas pueden ser utilizadas también con cadenas:
Ej.
Prelude> length "Hola" 4
Prelude> "Hola, " ++ "amigo" Hola, amigo

En las tuplas, el orden de los elementos es importante y para cada combinación de tipos se crea un nuevo tipo.
Así, si: t1, t2, ..., tn son tipos y =2, entonces hay un tipo de n-tuplas escrito:
(t1, t2, ..., tn)
cuyos elementos pueden ser escritos también como
(x1, x2, ..., xn) donde cada x1, x2,..., xn
tiene tipos t1,t2, ..., tn respectivamente.
Ejemplos:

• (1, ’{a}’) :: (Int, Char): Tupla con los elementos 1 (entero) y ’a’ (caracter)
• ("mono", True, 2) :: ([Char], Bool, Int) Tupla con tres elementos: la cadena "mono", el boolean True y el numero 2;
• ([1,2], sqrt) :: ([Int], Float->Float) Tupla con dos elementos: la lista de enteros [1,2] y la función del tipo de-float-a-float sqrt;
• (1, (2,3)) :: (Int, (Int,Int)) : Tupla con dos elementos: el numero 1, y la tupla de los números 2 y 3.
• (1, [2], 3) :: (Int, [Int], Int)
• ('a', False) :: (Char, Bool)
• ((1,2),(3,4)) :: ((Int, Int), (Int, Int))
• Existe una tupla especial con 0 elementos denominada tipo unidad y se escribe como ().

• Pareja: Tupla con dos elementos.
• Terna: Tuplas con tres elementos.
• No existen tuplas de un elemento: la expresión de un entero se puede escribir entre paréntesis

Tal punto puede ser descrito por una lista o por una pareja. En los dos casos es posible definir funciones que hagan algo con puntos. Por ejemplo, una función que calcule la distancia hasta el origen.
La función distanciaL es la versión que usa una lista, distanciaT es la versión para una tupla:
distanciaL :: [Float] -> Float
distanciaL [x,y] = sqrt (x*x+y*y)
distanciaT :: (Float,Float) -> Float
distanciaT (x,y) = sqrt (x*x+y*y)

Mientras se llame la función correctamente, no existe diferencia. Sin embargo, podría suceder que se llamase a la función (por error al teclear, o error lógico) en algún lugar en el programa con tres coordenadas.

Con el uso de distanciaT, el intérprete da un aviso durante el análisis de las funciones: una tupla con tres elementos es diferente de una tupla con dos elementos.
En el caso de distanciaL el intérprete no dice nada: el programa no tiene conflictos de tipos.

Pero cuando se usa el programa, resulta que la función distanciaL no esta definida para listas con tres elementos.
El uso de tuplas en vez de listas es entonces útil para detectar errores lo antes posible.
Otro caso en que las tuplas son realmente útiles es cuando se necesitan funciones con más de un resultado.
Las funciones de varios parámetros son posibles gracias al mecanismo de currificacion; las funciones que tienen varios resultados solamente son posibles agrupando los resultados en una tupla. La tupla en total es entonces un resultado.

Un ejemplo de una función que en realidad tiene dos resultados, es la función splitAt que esta definida en el preludio. Esta función devuelve los resultados de take y drop de una vez.
Por tanto, se puede definir la función de la siguiente forma:
splitAt :: Int -> [a] -> ([a],[a]) splitAt n xs = (take n xs, drop n xs)

El trabajo de estas dos funciones se puede hacer de una vez, por eso se ha definido realmente la función splitAt de forma mas eficiente:

splitAt :: Int -> [a] -> ([a], [a])
splitAt 0 xs = ([] , xs)
splitAt n [] = ([] , [])
splitAt (n+1) (x:xs) = (x:ys, zs)
where (ys,zs) = splitAt n xs

La llamada splitAt 2 "gofer" devuelve la pareja ("go","fer") como resultado. En la definición se puede ver (con una llamada recursiva) como se puede usar una tupla resultante: utilizando patrones (en el ejemplo (ys,zs)).

Una definición de tipo es muy útil en estos casos. Con una definición de tipo es posible dar un nombre (mías claro) a un tipo, por ejemplo:
type Punto = (Float,Float)
Con esta definición se pueden escribir las declaraciones de tipo de forma más clara:
distancia :: Punto -> Float
diferencia :: Punto -> Punt -> Float
sup_poligono :: [Punto] -> Float
transf_poligono :: (Punto->Punto) -> [Punto] -> [Punto]

Mejor todavía sería hacer una definición de tipo para ‘polígono’:
type Polígono = [Punto]
sup_poligono :: Polígono -> Float
transf_poligono :: (Punto->Punto) -> Polígono -> Polígono

Con definiciones de tipo hay que tener presentes algunos puntos:

• La palabra type es una palabra reservada especialmente para estas definiciones de tipo;
• El nombre de un tipo debe empezar por una letra mayúscula (es una constante, no es una variable);
• Una declaración de un tipo especifica el tipo de una función; una definición de tipo define un nuevo nombre para un tipo. El intérprete usa el nombre definido simplemente como una abreviatura. Si se pide el tipo de una expresión al intérprete, este muestra (Float,Float) en vez de Punto.

Con una definición de datos se puede construir un tipo IntOrChar que tenga como elementos enteros y caracteres:
data IntOrChar = Ent Int
| Car Char
Con esto se puede hacer una lista mezclada:
xs :: [IntOrChar]
xs = [ Ent 1, Car ’a’, Ent 2, Ent 3 ]

El único precio es que se tiene que marcar cada elemento con una función constructora Ent o Car.
Estas funciones se pueden interpretar como funciones de conversión;
Ent :: Int -> IntOrChar
Car :: Char -> IntOrChar
cuyo uso se puede comparar con el uso de las funciones primitivas
round :: Float -> Int
chr :: Int -> Char

Con las definiciones de datos realmente se pueden hacer nuevos tipos, de modo que no se pueda intercambiar un Ratio con cualquier otro tipo (Int,Int). En vez de la definición de tipos podemos escribir la siguiente definición de datos:
data Ratio = Rat (Int,Int)

Existe entonces solamente una función constructora. Para hacer una fracción con el numerador 3 y el denominador 5, no es suficiente escribir (3,5), sino se tiene que escribir Rat (3,5). Como tipos de unión se puede interpretar a la función Rat como función de conversión de (Int,Int) a Ratio.

Este método se usa mucho para hacer tipos abstractos. Un tipo abstracto consiste en una definición de datos y una serie de funciones que se pueden aplicar al tipo definido (en el caso de Ratio por ejemplo:
qSum, qRes, qMul en qDiv).

Como nombre de una función constructora, muchas veces se elige el mismo nombre que el tipo. Por
ejemplo:
data Ratio = Ratio (Int,Int)

• El parámetro de la llamada recursiva es mas simple que el parámetro de la función que se quiere definir 0:55 07/04/2005(por ej., numéricamente menor o una lista mas corta);
• Existe una definición no recursiva para un caso base.

• El caso base es n==0; se puede calcular el resultado directamente (sin recursión).
• En el caso n>0 existe una llamada recursiva, es decir fac (n-1).
• El parámetro de esta llamada (n-1) es menor que n.

El parámetro de la llamada recursiva (n) es menor que el parámetro de la función que se quiere definir (n+1).
El uso de patrones tiene mucha relación con la tradición matemática del usar inducción.

Así, la definición matemática de la función potencia puede ser usada casi directamente como

x ^ 0 = 1
x ^ (n+1) = x * x^n

La definición recursiva que usa patrones para distinguir diferentes casos, en lugar de expresiones booleanas, se llama también definición inductiva.

Las funciones sobre listas también pueden ser recursivas. Una lista es ‘menor’ que otra si tiene menos elementos. Así, función suma, puede ser definida de diferentes maneras.

• Definición recursiva con expresiones booleanas es:
  suma lista | lista==[] = 0 (Sume la lista; si la lista esta vacía de por resultado igual a cero)
  | otherwise = head lista + suma (tail lista) (sino sume la cabeza de lista más la suma de cola)
• Version inductiva (usando patrones):
  suma [] = 0
  suma (cabeza:cola) = cabeza + suma cola

  Es mas clara una definición con patrones, porque las diferentes partes en el patrón pueden conseguir un nombre directamente, como cabeza y cola en la función suma, cuya versión recursiva requiere funciones estándar head y tail para distinguir las diferentes partes en lista

Regla para la comparación de patrones

• Se comprueban los patrones correspondientes a las distintasecuaciones en el orden dado por el programa, hasta que seencuentreuna que unifique.
• Dentro de una misma ecuación se intentanunificarlos patrones correspondientes a losargumentos de izquierda a derecha.
• En cuanto un patrón falla para un argumento, se pasa a lasiguiente ecuación.

La definición de la conjunción y disyunción devalores lógicosusa patrones constantes (TrueyFalseson dos constructores de datos para el tipoBool)

Patrones para listas
Es posible utilizar patrones al definirfuncionesque trabajen con listas.
[ ] sólo unificacon un argumento que sea unalista vacía.
[x ], [x ,y], etc. sólo unifican con listas de uno,dos, etc. argumentos.

(x :xs) unificacon listas con al menos un elemento
suma :: [Integer] →Integer
suma [ ] = 0
suma (x :xs) = x + suma xs

Patrones para tuplas
primero2 :: (Integer,Integer) →Integer
primero2 (x ,y) = x
primero3 :: (Integer,Integer,Integer) →Integer
primero3 (x ,y,z ) = x

Los patrones pueden anidarse.
sumaPares:: [(Integer,Integer)] →Integer
sumaPares[ ] = 0
sumaPares((x ,y) :xs) = x + y +sumaPares xs

Patrones aritméticos
Es unpatrón de la forma (n + k), donde k esun valor constante natural.
factorial :: Integer →Integer
factorial 0 = 1
factorial (n + 1) = (n + 1) *factorial n

En una llamada a la función se dan parámetros actuales a la función, así en: f 17 (1+g 6)

• El parámetro actual es 17 que corresponde a x.
• El parámetro actual es (1+g 6) que corresponde a y.