-- EJERCICIO 1

f c1 c2 = [c1,c2]
-- a) f :: a -> a -> [a]
-- b) f 'k' :: Char -> [Char]
--    f True :: Bool -> [Bool] 
{- 	Main> :t (f 'k' True)
	ERROR - Type error in application
	*** Expression     : f 'k' True
	*** Term           : 'k'
	*** Type           : Char
	*** Does not match : Bool
-}
-- uncurry f :: (a,a) -> [a] 
{-	Main> (uncurry f) 'k'
	ERROR - Type error in application
	*** Expression     : uncurry f 'k'
	*** Term           : 'k'
	*** Type           : Char
	*** Does not match : (a,b)
-}
-- Main> :t (uncurry f) ('k','h')
-- uncurry f ('k','h') :: [Char]

-- Main> :t f 'k' 'h'
-- f 'k' 'h' :: [Char]

-- Main> :t f ('k','h')
-- f ('k','h') :: (Char,Char) -> [(Char,Char)]

-- Los únicos que no son ni error ni una función son
-- (uncurry f) ('k','h') cuyo valor es "kh" 
--  f 'k' 'h' cuyo valor es "kh" 
-- f ('k','h') ('x','z') cuyo valor es [('k','h'),('x','z')] 


-- EJERCICIO 2

infixl 2 #
(#) :: Bool -> Bool -> Bool

-- a)
b1 # b2 = if b1==b2 then False else True

-- b) (True #) :: Bool -> Bool 
-- c) (#) True :: Bool -> Bool 
-- d) (# False) :: Bool -> Bool
-- sólo gracias a que la función es conmutativa y 
-- ((#) False) es la misma función que (False #) que coincide
-- (por la conmutatividad) con (# False)

-- EJERCICIO 3

swap (x,y) = (y,x)
-- swap :: (a,b) -> (b,a)  

-- twice f x = f (f x)
-- twice :: (a -> a) -> a -> a 

-- twice swap (1,2) da (1,2)
-- twice swap (True,1) da error

twice f = f . f
-- es totalmente equivalente:
-- twice f x = (f . f) x = f (f x)

-- EJERCICIO 4

-- a)  3 (!!) [True,False,True] => error de tipo
-- b) (!!) 3 [True,False,True] => error de tipo
-- c) (!!) [True,False,True] 3  => error de evaluación (fuera de rango)
-- d) [True,False,True] !! 3 => idem anterior (es quivalente)
-- e) [True,False,True] !! 1 => False
-- f) (!! 3) => es una función (!! 3):: [a] -> a  (no show function)
-- g) (!!) 3 => idem anterior (es equivalente)
-- h) ([True,False,True] !!) => es una función de tipo Int -> Bool  (no show function)
-- i) (!!) [True,False,True] => equivalente a la anterior

-- EJERCICIO 5

-- a) map (<0)  :: (Ord a, Num a) => [a] -> [Bool]
-- b) map (<) 0 => error 
-- c) map (!! 0) :: [[a]] -> [a]  
-- d) map ([1..10] !!) :: (Enum a, Num a) => [Int] -> [a]   
-- e) map ([1..10] !!) [1,4,8]  => [2,5,9] :: (Enum a, Num a) => [a] 
-- f) map (uncurry (#)) [(True,False)] => [True] :: [Bool]
-- g) map (uncurry (#)) :: [(Bool,Bool)] -> [Bool]    
-- h) map (uncurry (#)) [(True,True),(True,False)] => [False,True] :: [Bool]