-- Funktionen, die davon abhängen, dass gewisse Operationen gegeben sind
-- Erste Version mit zusätzlichem Parameter

gleich_ist_in :: (t->t->Bool) -> t -> [t] -> Bool
gleich_ist_in eq a [] = False
gleich_ist_in eq a (b:l) = eq a b || gleich_ist_in eq a l

-- bessere Möglichkeit unter Verwendung von Klassen
-- Vorteile: kürzer, universell verwendbar

ist_in :: Eq t => t -> [t] -> Bool
a `ist_in` [] = False
a `ist_in` (b:l) = a == b || a `ist_in` l

-- Beispiel für die Vereinbarung von Klassen

class Sichtbar t where
   zeig :: t -> String
   größe :: t -> Int 

-- Beispiele für die vereinbarung von Instanzen

instance Sichtbar Char where
   zeig c = [c]
   größe _    = 1

instance  Sichtbar Int where
   zeig n = show n
   größe n = length (show n)

instance Sichtbar t => Sichtbar [t] where
   zeig = concat . map zeig
   größe     = foldr (+) 1 . map größe  

{- Folgende Definition ist unzulässig, weil nur polymorphe, strukturierte Typen 
    als Instanzen vereinbart werden dürfen.

instance  Sichtbar [Char] where  
   zeig = concat . map zeig
   größe     = foldr (+) 1 . map größe
-}
-- Beispiel für Mehrfachabhängigkeiten (Multiple Constraints)

zeigSortiert :: (Ord t, Sichtbar t) => [t] -> String
zeigSortiert = zeig . qSort

qSort :: Ord t => [t] -> [t]
qSort [] = []
qSort (x:xs) = qSort [ y | y <- xs, y <= x ] ++ [x] ++
                      qSort [ y | y <- xs, y > x ]

bspListe :: [Int]
bspListe = [324,432,6,324,67,43,7,5]

test :: String
test = zeigSortiert bspListe