len [] = 0
len (_:xs) = 1 + len xs
hd (x:_) = x
-- append xs ys = xs ++ ys
append [] ys' = ys'
append xs' [] = xs'
append (x:xs) ys' = x : (append xs ys')
-- id x = x
idl [] = []
idl (x:xs) = (x : idl xs)
undex :: [a] -> Int -> a
-- undex xs n = xs !! n
undex [] n = error "no undex at that value"
undex (_:xs) (n+1) = undex xs n
undex (x:_) 0 = x
philter :: (a -> Bool) -> [a] -> [a]
philter p [] = []
philter p (x:xs) = (if p x then (x:) else id) (philter p xs)
mapp :: (a -> b) -> [a] -> [b]
mapp f [] = []
mapp f (x:xs) = f x : mapp f xs
unz :: [ (a,b) ] -> ( [a],[b] )
unz [] = ( [] ,[] )
unz ( x :xs) = ( fst x : fst (unz xs) , snd x : snd (unz xs) )
unz ((a,b):xs) = ( a : fst (unz xs) , b : snd (unz xs) )
unz ((a,b):xs) = ( a : fst u , b : snd u )
where u = unz xs
unz ((a,b):xs) = ( a : ua , b : ub )
where (ua,ub) = unz xs
unz ((a,b):xs) = (a:ua, b:ub) where (ua,ub) = unz xs
-----------------------
elem' x [] = False
elem' x (y:ys) = if x==y then True else elem' x ys
peek x [] = Nothing
peek x ((y,z):ps) = if x==y then Just z else peek x ps
fold :: (a -> b -> b) -> b -> [a] -> b
fold f r [] = r
fold f r (x:xs) = f x (fold f r xs)
f b n = if b then n else 2*n
rev [] = []
rev (x:xs) = rev xs : (x:[])
------------------------
count :: (a->Bool) -> [a] -> Int
-- count p [] = 0
-- count p (x:xs) = (if p x then (1+) else id) (count p xs)
-- count p xs = length (filter p xs)
-- count p xs = (length . filter p) xs
count p = length . filter p
-- stutter n xs = concat (replicate n xs)
-- stammer n xs = concat (map (replicate n) xs)
stutter n = concat . replicate n
stammer n = concat . map (replicate n)
tkot n = stutter n . stammer n