EDAF40

-- 1. (EDAF, EDAN)
f = flip $ (/) . (3-)
g = flip $ (flip map) . (filter odd) . (flip take (iterate (+1) 1))

-- 2. (EDAF)
g :: [Int] -> [String]

-- 3. (EDAF)
-- type - type synonym, no new type declared
-- data - new datatype
-- newtype - new datatype with only one unary constructor

-- 4. (EDAF) 
uncurry map

-- 5. (EDAF)
f n = [(a,b,c)| a <- [1..n], b<- [1..n], c<-[1..n], a<=b, b<=c, a^2 + b^2 == c^2]

-- 6. (EDAF)
-- (a)
data Proposition = Var String | And Proposition Proposition | Or Proposition Proposition | Not Proposition

--- (b)
vars :: Proposition -> [String]
vars (Var x) = [x]
vars (Or p1 p2) = nub $ (++) (vars p1) (vars p2)
vars (And p1 p2) = nub $ (++) (vars p1) (vars p2)
vars (Not p) = vars p

--- (c)
truthValue :: Proposition -> [(String, Bool)] -> Bool

findVal :: String -> [(String, Bool)] -> Bool
findVal name xs = fromJust $ lookup name xs

truthValue (Var x) vals = findVal x vals
truthValue (Not p) vals = not $ truthValue p vals
truthValue (And p1 p2) vals = (&&) (truthValue p1 vals) (truthValue p2 vals)
truthValue (Or p1 p2) vals = (||) (truthValue p1 vals) (truthValue p2 vals)

--- (d)
tautology :: Proposition -> Bool

valslist :: Proposition -> [[(String,Bool)]]

boolperms vs :: [String] -> [[(String,Bool)]]
boolperms [] = []
boolperms (x:[]) = [[(x,True)],[(x,False)]]
boolperms (x:xs) = (++) (map ((x,True):) $ boolperms xs) (map ((x,False):) $ boolperms xs)

valslist = boolperms . vars 

tautology p = and $ map (truthValue p) (valslist p)

--========================================================
-- EDAN

-- 2. (EDAN)
-- (a)
(.)(:) :: (a -> b) -> a -> [b] -> [b]
-- (b)
(:)(.) :: [(b -> c) -> (a -> b) -> a -> c] -> [(b -> c) -> (a -> b) -> a -> c]
-- (c)
((.):) :: [(b -> c) -> (a -> b) -> a -> c] -> [(b -> c) -> (a -> b) -> a -> c]
-- (d)
(:(.)) TYPFEL!
-- (e)
([]>>=)(\_->[(>=)]) :: Ord a => [a -> a -> Bool]

-- 3. (EDAN)

-- PROOF, TO BE WRITTEN

-- 4. (EDAN)

uncurry $ flip map

-- 5. (EDAN)
instance (Ord a, Ord b) => Ord (a,b) where
  (>) (a,b) (c,d) = (a > c) || ((a == c) && (b > d))
  (>=) (a,b) (c,d) = (a > c) || ((a == c) && (b >= d))
  (<) (a,b) (c,d) = (a < c) || ((a == c) && (b < d))
  (<=) (a,b) (c,d) = (a < c) || ((a == c) && (b <= d))
  max (a,b) (c,d)
    | (a,b) >= (c,d) = (a,b)
    | otherwise      = (c,d)
  min (a,b) (c,d)
    | (a,b) <= (c,d) = (a,b)
    | otherwise      = (c,d)

-- NOTE -- the original solution below does not give the lexicographic order
instance (Ord a) => Ord [a] where
   (>) xs ys   = (and (zipWith (>=) xs ys)) && (not (xs == ys))
   (>=) xs ys = (and (zipWith (>=) xs ys)) 
   (<) xs ys   = (and (zipWith (<=) xs ys)) && (not (xs == ys))
   (<=) xs ys = (and (zipWith (<=) xs ys)) 
   min xs ys
     | xs <= ys  = xs
     | otherwise = ys
   max xs ys
     | xs >= ys  = xs
     | otherwise = ys

-- while this one should
instance (Ord a) => Ord [a] where
  (>) [] [] = False
  (>) _ [] = True
  (>) [] _ = False
  (>) (x:xs) (y:ys) = (x > y) || (x == y) && xs > ys
  (>=) xs ys = (xs > ys) || (xs == ys)
  (<) [] [] = False
  (<) [] _ = True
  (<) _ [] = False
  (<) (x:xs) (y:ys) = (x < y) || (x == y) && xs < ys
  (<=) xs ys = (xs < ys) || (xs == ys)
  min xs ys
     | xs <= ys  = xs
     | otherwise = ys
  max xs ys
     | xs >= ys  = xs
     | otherwise = ys

   
-- 6. (EDAN)

-- (a)
f :: (Monad m, Num b) => m b -> m b -> m b
-- (b)
[2,4,8,4,8,16,6,12,24]
-- (c)
Nothing
-- (d)
return 5 :: (Monad m, Num a) => m a
-- (e)
""
-- (f)
[]