-- 1: Infieran el tipo
-- 2: Mejoren la expresividad de las funciones llamadas f y g. Si es alguna funcion del Prelude que ya conocen, denle ese nombre

f (x,_)       = x

f (_,y)       = y

g f x y     = f (x,y)

g f p     = f (fst p) (snd p)

f    x         = x

f k _       = k

(f . g) x       = f (g x)

flip f x y      = f y x

f $ x           = f x

head (x:_)        = x

last [x]          = x
last (_:xs)       = last xs

tail (_:xs)       = xs

init [x]          = []
init (x:xs)       = x : init xs

null []           = True
null (_:_)        = False

[]     ++ ys      = ys
(x:xs) ++ ys      = x : (xs ++ ys)

g f xs          = [ f x | x <- xs ]

g p xs       = [ x | x <- xs, p x ]

f  xs          = foldl (++) [] xs

f            = foldl (\n _ -> n + 1) 0

(x:_)  !! 0       = x
(_:xs) !! n | n>0 = xs !! (n-1)

g f z []      = z
g f z (x:xs)  = g f (f z x) xs

g f (x:xs)   = foldl f x xs

iterate f x       = x : iterate f (f x)

g x          = x : g x

f n x     = take n (repeat x)

cycle             = concat.repeat

f n _  | n <= 0  = []
f _ []           = []
f n (x:xs)       = x : f (n-1) xs

f           = foldl1 max
f           = foldl1 min

g f       = concat . map f

f               = zipWith  (\a b -> (a,b))

zipWith z (a:as) (b:bs)   = z a b : zipWith z as bs
zipWith _ _      _        = []