Funciones estándar para procesar listas

head Concatenar (++)

Obtener el primer elemento de una Concatenación de dos listas.
lista.
(++) :: [a] -> [a] -> [a]
head :: [a] -> a
[] ++ ys = ys
head (x:_) =x
(x:xs) ++ ys = x : (xs ++ ys)
last
(++) es un operador infijo
Obtener el último elemento de una
length
lista.
Cantidad de elementos en una
last :: [a] -> a
lista.
last [x] =x
length :: [a] -> Int
last (_:xs) = last xs
length [] =0
tail
length (x:xs) = 1 + length xs
Obtener el resto de una lista.
Selección por índice (!!)
tail :: [a] -> [a]
Seleccionar el k-ésimo elemento de
tail (_:xs) = xs una lista.
init (!!) :: [a] -> Int -> a
Obtener el resultado de quitar el (x:_) !! 0 =x
último de una lista.
(_:xs) !! n | n>0 = xs !! (n-1)
init :: [a] -> [a]
(_:_) !! _ = error "Prelude.!!:
init [x] = [] negative index"
init (x:xs) = x : init xs [] !! _ = error "Prelude.!!: index
too large"
El patrón [x] es una abreviatura de
(x:[]) * Este operador permite tratar una
lista como un arreglo. No se
null
recomienda su uso extensivo.
Verificar si una lista es vacía.
take
null :: [a] -> Bool
Tomar los n primeros elementos de
null [] = True una lista.
null (_:_) = False take :: Int -> [a] -> [a]
take n _ | n <= 0 = []
take _ [] = [] takeWhile p (x:xs)
take n (x:xs) = x : take (n-1) xs |px = x : takeWhile p xs
Si hay menos de n elementos, se | otherwise = []
toman los que haya.
El elemento que no cumple la
drop propiedad se incluye en el
resultado?
Borrar los n primeros de una lista.
dropWhile
drop :: Int -> [a] -> [a]
Borra elementos del principio de la
drop n xs | n <= 0 = xs
lista hasta encontrar el primero
drop _ [] = [] que no cumpla la propiedad.

drop n (_:xs) = drop (n-1) xs dropWhile :: (a -> Bool) -> [a] ->
[a]
Si hay menos de n, queda la lista
vacía. dropWhile p [] = []

splitAt dropWhile p xs@(x:xs')

Devolver un par de listas, la |px = dropWhile p xs'

primera contiene los primeros n
| otherwise = xs
elementos, la segunda los
restantes.  El elemento que no cumple la
propiedad se borra?
splitAt :: Int -> [a] -> ([a], [a])
span, break
splitAt n xs | n <= 0 = ([],xs)
Es una combinación de takeWhile
splitAt _ [] = ([],[])
y dropWhile.
splitAt n (x:xs) = (x:xs',xs'')
span, break :: (a -> Bool) -> [a] -
where (xs',xs'') = splitAt (n-1) xs > ([a],[a])

 Qué sucede si hay menos de n span p [] = ([],[])

elementos?
span p xs@(x:xs')
takeWhile
|px = (x:ys, zs)
Toma elementos del principio de la
| otherwise = ([],xs)
lista hasta encontrar el primero
que no cumpla la propiedad. where (ys,zs) = span p
xs'
takeWhile :: (a -> Bool) -> [a] ->
[a] break p = span (not . p)
takeWhile p [] = []
lines unwords (w:ws) = w ++ ' ' : unwords
ws
Dado un texto (lista de caracteres)
retorna la lista de las líneas. reverse
lines :: String -> [String] Invertir los elementos de una lista
lines "" = [] reverse :: [a] -> [a]
lines s = let (l,s') = break ('\n'==) s reverse [] = []
in l : case s' of [] -> [] reverse (x:xs) = reverse xs ++ [x]
(_:s'') -> lines s'' Nota: Esta no es la definición del
preludio de Haskell
El carácter separador de línea es
'\n' elem
words Verificación de pertenencia.
Dado un texto, retorna la lista de notElem,elem :: Eq a => a -> [a] ->
las palabras. Bool
words :: String -> [String] elem _ [] = False
words s = case dropWhile isSpace s elem x (y:ys) = (x == y) || elem x ys
of
notElem x xs = not (x `elem` xs)
"" -> []
Nota: Estas no son las definiciones
s' -> w : words s'' del preludio Haskell
where (w,s'') = break zip
isSpace s'
Formar una lista a partir de dos
unlines listas con los pares de elementos
en la misma posición.
Es la operación inversa de lines
zip :: [a] -> [b] -> [(a,b)]
unlines :: [String] -> String
unlines [] = []
zip (x:xs) (y:ys) = (x,y) : zip xs ys
unlines (l:ls) = l ++ '\n' : unlines ls
zip (x:xs) [] = []
unwords
zip [] zs = []
Es la operación inversa de words
 Qué sucede si las listas son
unwords :: [String] -> String
de distinto largo?
unwords [] = ""
unwords [w] =w
unzip (ws,rs) = getWord' xs
Es la operación inversa de zip Saltear espacios
unzip :: [(a,b)] -> ([a],[b]) Eliminar espacios del principio.
unzip [] = ([],[]) dropSpace :: String -> String
unzip ((a,b):xs) = (a:as,b:bs) dropSpace [] = []
Espacios dropSpace (x:xs)
whitespace :: String | elem x whitespace = dropSpace
xs
whitespace = ['\n','\t',' ']
| otherwise = (x:xs)
Obtener la primera palabra
Splitting
getWord :: String -> String
Una palabra es un String
getWord [] = []
type Word = String
getWord (x:xs)
Cortando en palabras (splitting)
| elem x whitespace = []
splitWords :: String -> [Word]
| otherwise = x : getWord xs
splitWords st = split (dropSpace st)
Borrar la primera palabra
split :: String -> [Word]
dropWord :: String -> String
split [] = []
dropWord [] = []
split st
dropWord (x:xs)
= (getWord st) : split (dropSpace
| elem x whitespace = (x:xs)
(dropWord st))
| otherwise = dropWord xs
Splitting'
Primera palabra y el resto.
splitWords' :: String -> [Word]
Esta función combina getWord y
splitWords' = split . dropSpace
dropWord
split :: String -> [Word]
getWord' :: String -> (String,String)
split [] = []
getWord' [] = ([],[])
split st
getWord' (x:xs) =
= ws : (splitWords' cs)
| elem x whitespace = ("",xs)
where
| otherwise = (x:ws, rs)
(ws,cs) = getWord' st
where
Splitting Lines dropLine
Partiendo en líneas de largo Borrar la primera línea
constante
dropLine :: Int -> [Word] -> Line
-- El largo de la línea
lineLen :: Int
dropLine = ...
lineLen = 80
Queda como un ejercicio
Una línea es una lista de palabras
Splitting into lines.
type Line = [Word]
splitLines :: [Word] -> [Line]
getLine
splitLines [] = []
Obtener la primera línea
splitLines ws
getLine :: Int -> [Word] -> Line
= getLine lineLen ws
getLine len [] = []
: splitLines (dropLine lineLen
getLine len (w:ws) ws)
| length w <= len = w : restOfLine fill
| otherwise = [] La solución al problema queda
planteada como sigue
where
fill :: String -> [Line]
newlen = len - (length w + 1)
fill = splitLines . splitWords
restOfLine = getLine newlen ws