--------------------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 = 0 --TODO
  
--------------------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

--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.
	
--ex: Operații
--findMin :: PHeap a -> a

--insert :: Ord a => a -> PHeap a -> PHeap a

--mergeAll :: Ord a => [PHeap a] -> PHeap a

--deleteMin :: Ord a => PHeap a -> PHeap a

--toPHeap :: Ord a => [a] -> PHeap a
--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

--ins :: Ord a => a -> SList a -> SList a

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