Haskell Hero

La función unaria que devuelve el primer elemento de la lista.

Definición

head       ::  [a] -> a
head (x:_)  =  x

Ejemplo de uso

head [1,2,3]  ~>  1
head "ABC"  ~>  'A'
head [[2.5, 3.0], [4.8, 10.69, 9.12], []]  ~>  [2.5, 3.0]

La función unaria que devuelve la lista sin su primer elemento.

Definición

tail       ::  [a] -> [a]
tail (_:s)  =  s

Ejemplo de uso

tail [1,2,3]  ~>  [2,3]
tail "ABC"  ~>  "BC"
tail [[2.5, 3.0], [4.8, 10.69, 9.12], []]
      ~>  [[4.8, 10.69, 9.12], []]

La función unaria null devuelve True si la lista está vacía o False si contiene al menos un elemento.

Definición

null       ::  [a] -> Bool
null []     =  True
null (_:_)  =  False

Ejemplo de uso

null []  ~>  True
null ""  ~>  True
null [2,3]  ~>  False
null "KK"  ~>  False

La función unaria que devuelve el número de elementos de la lista.

Definición

length       ::  [a] -> Int
length []     =  0
length (x:s)  =  1 + length s

Ejemplo de uso

length []  ~>* 0
length [1,2,3,4]  ~>*  4
length "ABCDE"  ~>*  5
length ["A", "AB", "&+#!$"]  ~>*  3

La evaluación modelo

length [1,2,3] o length 1:[2,3]

    x se sustituye por 1, s se sustituye por [2,3]
~>  1 + length [2,3]
    x se sustituye por 2, s se sustituye por [3]
~>  1 + 1 + length [3]
    x se sustituye por 3, s se sustituye por []
~>  1 + 1 + 1 + length []
    length [] se evalua según la primera ecuación
~>  1 + 1 + 1 + 0
~>* 3

Nota

Nota: Ya que la variable x no aparece en la parte derecha de la segunda ecuación, la podemos sustituir por un guión bajo.

length (_:s)  =  1 + length s

La concatenación de dos listas se hace utilizando el operador binario (++). Durante la evaluación los elementos de la primera lista tienen que moverse uno por uno a la otra lista.

Definición

(++)       ::  [a] -> [a] -> [a]
[]    ++ t  =  t
(x:s) ++ t  =  x : (s ++ t)

Ejemplo de uso

[1,2] ++ [3,4,5] ~>* [1,2,3,4,5]
"ABC" ++ "DE" ~>* "ABCDE"
[] ++ [True, False] ~> [True, False]

La evaluación modelo

[1,2,3] ++ [4] lo que es sustituible por 1:[2,3] ++ [4]
Según la segunda ecuación
    x = 1, s = [2,3], t = [4]
~>  1 : ([2,3] ++ [4])
    x = 2, s = [3], t = [4]
~>  1 : (2 : ([3] ++ [4]))
    x = 3, s = [], t = [4]
~>  1 : (2 : (3 : ([] ++ [4])))
    Según la primera ecuación
~>  1 : (2 : (3 : [4])) ≡ [1,2,3,4]

Nota

Durante la concatenación de listas los elementos de la primera lista tienen que moverse a la otra lista. Esto significa que la evaluación de la expresión [1,2,3,4,5] ++ [] tardará mucho más que la evaluación de la expresión [] ++ [1,2,3,4,5] que estará hecho después de un paso.

Un elemento se selecciona de una lista con el operador binario (!!). La expresión s !! k, se evalúa al elemento ubicado en la posición k de la lista s.

• se indexa desde cero
• Se supone que k < length s o un error ocurre

Definición

(!!)       ::  [a] –> Int –> a
(x:_) !! 0  =  x
(_:s) !! k  =  s !! (k-1)

Ejemplo de uso

[1,2,3] !! 0  ~>*  1
"ABCDE" !! 4  ~>*  'E'
[[1,2], [3], [], [4,5]] !! 3  ~>*  [4,5]

La función binaria en que la expresión take n s se evalúa a una lista que contiene primeros n elementos de la lista s. Si n > length s, se devuelve toda la lista s.

Definición

take         ::  Int –> [a] –> [a]
take 0 _      =  []
take _ []     =  []
take n (x:s)  =  x : take (n-1) s

Ejemplo de uso

take 2 [1,2,3,4] ~>* [1,2]
take 3 [2] ~>* [2]
take 1 "ABCD" ~>* "A"

La función binaria en la que la expresión drop n s se evalúa a la lista s sin los primeros n elementos. Si n > length s, la expresión evalúa a una lista vacía.

Definición

drop         ::  Int –> [a] –> [a]
drop 0 s      =  s
drop _ []     =  []
drop n (_:s)  =  drop (n-1) s

Ejemplo de uso

drop 2 [1,2,3,4,5]  ~>*  [3,4,5]
drop 0 [1,2,3]  ~>*  [1,2,3]
drop 8 [1,2,3]  ~>*  []

La función unaria que concatena listas en una lista de listas en una lista.

Definición

concat       ::  [[a]] –> [a]
concat []     =  []
concat (s:t)  =  s ++ concat t

Ejemplo de uso

concat [[1,2], [3,4,5], [], [6,7]]  ~>*  [1,2,3,4,5,6,7]
concat ["ABC", "", "DEF"]  ~>*  "ABCDEF"