--------------------Supraîncărcare
myElem _ [] = False
myElem a (x:xs) = a == x || myElem a xs

--myElem2 :: (a -> b -> Bool) -> a -> [b] -> Bool
myElem2 :: (a -> a -> Bool) -> a -> [a] -> Bool
myElem2 _ _ [] = False
myElem2 eq a (x:xs) = eq a x || myElem2 eq a xs


--------------------Clase: definiri, instanțieri
data Dice = S1 | S2 | S3 | S4 | S5 | S6 deriving (Eq, Ord, Enum)

instance Show Dice where
  show S1 = "[*]"
  show S2 = "[:]"
  show S3 = "[***]"
  show S4 = "[::]"
  show S5 = "[:*:]"
  show S6 = "[:::]"

class Valuable a where
  value :: a -> Int

instance Valuable Dice where
  --ex: cu list comprehension
  value dice = head [ v | (v, d) <- zip [1 ..] [S1 ..], d == dice ]
  
--------------------Contexte
--rollSum :: (Dice, Dice) -> Int
rollSum (x, y) = value x + value y

myLen lst
  | lst == [] = 0
  | otherwise = 1 + myLen (tail lst)

myLen2 lst
  | null lst = 0
  | otherwise = 1 + myLen2 (tail lst)
  

--------------------Aplicație: Mergeable
--ex: o clasă pentru containerele care admit operația merge
class Mergeable t where
  merge :: Ord a => t a -> t a -> t a

--TDA: Pairing Heap
-- Pairing Heap este o coadă de priorități eficientă, implementată ca un 
-- min-heap multi-căi. Operația fundamentală este 'merge'. Pe această
-- operație se bazează restul funcțiilor din interfața tipului Pairing Heap.
data PHeap a = Empty | Node a [PHeap a] deriving Show

--ex: Instanțierea clasei Mergeable pentru Pairing Heap
-- PH cu rădăcina mai mare devine primul fiu al celuilalt.
instance Mergeable PHeap where
  merge Empty h = h
  merge h Empty = h
  merge h1@(Node x hs1) h2@(Node y hs2)
    | x <= y = Node x (h2 : hs1)
	| otherwise = Node y (h1 : hs2)
	
--ex: Operații
findMin :: PHeap a -> a
findMin Empty = error "min on empty"
findMin (Node x _) = x

insert :: Ord a => a -> PHeap a -> PHeap a
insert x h = merge (Node x []) h

mergeAll :: Ord a => [PHeap a] -> PHeap a
mergeAll hs = foldr merge Empty hs

deleteMin :: Ord a => PHeap a -> PHeap a
deleteMin Empty = Empty
deleteMin (Node _ hs) = mergeAll hs

toPHeap :: Ord a => [a] -> PHeap a
toPHeap xs = foldr insert Empty xs
--Test: merge (toPHeap [5,1,7,6,2]) (toPHeap [8,0,5,3,4,1])

--TDA: Sorted List 
-- Sorted List reprezintă o listă sortată crescător.
data SList a = SNil | SCons a (SList a) deriving Show

--ex: Instanțierea clasei Mergeable pentru Sorted List
instance Mergeable SList where
  merge SNil l = l
  merge l SNil = l
  merge a@(SCons x xs) b@(SCons y ys)
    | x <= y = SCons x (merge xs b)
    | otherwise = SCons y (merge a ys)

ins :: Ord a => a -> SList a -> SList a
ins x SNil = SCons x SNil
ins x l@(SCons y ys)
  | x <= y = SCons x l
  | otherwise = SCons y (ins x ys)

toSList :: Ord a => [a] -> SList a
toSList xs = foldr ins SNil xs 
--Test: merge (toSList [5,7,1,6,2]) (toSList [8,1,5,0,3,4])