import Data.List
import Data.Maybe

--- Clasa Eq
-- TDA: Unordered List
newtype UList a = UList [a]

-- ex: Instanțiere Eq pentru (UList a) a. î. să conteze numărul de apariții, dar nu ordinea 
-- Hint: nub 	    

--- Clasa Ord	
type Name = (String, String)
names :: [Name] 
names = [("Frederic","Chopin"), ("Antonio","Vivaldi"), ("Maurice","Ravel")]

-- ex: O funcție care sortează lista după nume, nu după prenume
-- Hint: :t sortBy
  
-- Pot institui această relație de ordine și pentru alte operații (ex: <, >)?

--- Clasa Show  
{- ex:
Supraîncărcați afișarea funcțiilor unare cu parametru numeric, astfel:
- o funcție se afișează ca listă de 6 perechi:
 - fst: numerele de la 0 la 5
 - snd: valoarea funcției în aceste puncte
ex: show (*2) = "[(0,0),(1,2),(2,4),(3,6),(4,8),(5,10)]"
-}
  
--- Clasa Enum
data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun deriving (Eq, Ord, Show)

-- ex: Instanțiere Enum pentru Day, astfel încât succ Sun = Mon
  
--- Clasa Bounded
-- ex: O clasă CyclicEnum care ciclează pentru funcțiile prev și next:
-- prev minim = maxim, next maxim = minim
  

--------------------Containere
class Container t where
  contents :: t a -> [a]

instance Container [] where -- [a]; [a] ~ [] a
  contents = id

data List a = Nil | Cons a (List a) deriving Show

--ex: instanțierea clasei Container cu constructorul List (pt tipul List a)
  
-- ex: instanțierea cu Maybe
  
--ex: instanțierea clasei Functor cu constructorul List (pt tipul List a)
  
--ex: instanțierea clasei Foldable cu constructorul List (pt tipul List a)

-- fmap :: (a -> b) -> f a -> f b   (întoarcem un container cu valorile din container transformate)
-- exemplu: instance Functor []                                         
-- [1,2,3] :: [a] => fiecare valoare din listă este o valoare închisă în container, deci toate trebuie supuse transformării

--instance Functor Maybe 										
ex1 = fmap (+1) (Just 5)        -- Just {5}  :: Maybe a => Just (5+1) = Just 6
--instance Functor ((->) r)
ex2 = fmap (+1) (+1) 2          -- \x -> {x+1} :: (->) a b =>
                                -- fmap (+1) (\x -> {x+1}) = \x -> x+2 =>
								-- 4
--instance Functor ((,) a)      
ex3 = fmap (+1) (1,2)           -- (1,{2}) :: (,) a b  => (1,3)

-- foldl :: (a -> b -> a) -> a -> t b -> a   (întoarcem un rezultat bazat pe procesarea acumulatorului și a valorilor din container)
--instance Foldable ((,) a)
ex4 = foldl (+) 10 (1,2)        -- (1,{2}) :: (,) a b => 12

{-
eq :: a -> a -> Bool
eq x y = x == y
-}

{-
eq :: (Eq a, Eq b) => a -> b -> Bool
eq x y = x == y
-}