[Progra] Allgemeinster Typ in Haskell

[hand-of-fate]

Hi ich habe bei folgenden Funktionen Probleme den allgemeinsten Typ zu bestimmen..
kann mir das jemand erklären??

g x y = y (x ++ [5]) Lösung g :: [Int] -> ([Int] -> a) -> a

g x y = y ++ (map x y) Lösung g :: (a -> a) -> [a] -> [a]

f = \x->f (f x) Lösung f :: a -> a

g x y = [y, x 3] Lösung g :: (Int -> a) -> a -> [a]

g e h x = h (h(e x)) Lösung g :: (a -> b) -> (b -> b) -> a -> b

g h = [\x->x, \x-> h x, \x-> h(h x))] Lösung g :: (b -> b) -> [b -> b]

[dvs]

g x y = y (x ++ [5]) Lösung g :: [Int] -> ([Int] -> a) -> a

hier sieht man, dass 5 vom Typ Int ist, dann ist [5] vom Typ [Int].
"++" ist nur auf Listen definiert und Listen in Haskel haben immer den gleichen Typ also aus x++[Int] folgt x =[Int] damit die Konkatination klappt.
y ist eine Funktion, d.h. y::[Int]->a. Nun betrachtet man g x y und trägt einfach die bestimmten Typen für x und y ein, d.h g::[Int] -> ([Int] -> a) -> a, a ist unbekannt, wir wissen nicht worauf y abbildet.

[dvs]

g x y = y ++ (map x y) Lösung g :: (a -> a) -> [a] -> [a]

map x y: Hier ist schon klar, nach der Definition von map, dass x eine Funktion sein muss und y eine Liste, wobei map x y eine Liste vom Typ y zurückliefert damit y ++ (map x y) klappt. Also z.B. y hat den Typ [a].
Dann hat map x y auch den Typ [a]. Laut Definition von map ist map:: (a -> b) -> [a] -> [b], also wenn y=[a], dann muss x den Typ (a->a) haben.
Insgesamt dann (a->a) für x, [a] für y und [a] für das Ergebnis der Konkatenation. Irgendwie so )

[dvs]

f = \x->f (f x) Lösung f :: a -> a

wegen f(f x) muss wohl f x den gleichen Rückgabetyp mit x haben, z.B. a, weil f auf gleichem Eingabetyp definiert ist. Also f::a->a.

[dvs]

g x y = [y, x 3] Lösung g :: (Int -> a) -> a -> [a]

x3 sieht nach einer Funktion aus, die 3, also ein Int auf irgendwas abbildet, z.B. a, also x: Int -> a. Liste kann nur Werte vom gleichen Typ beinhalten, also muss y den Typ haben, der mit dem Rückgabewert von x-Funktion gleich ist, also a. Also für x: Int -> a, für y: a , Ergebnisliste: [a]
Man schreibt für Liste nur den Typ also nicht [a,a] sondern [a].

[dvs]

g h = [\x->x, \x-> h x, \x-> h(h x))] Lösung g :: (b -> b) -> [b -> b]

hier haben wir schon \x - > h(h x)) genauso wie oben mit \x ->f(f x), also nennen wir es b -> b. Alle anderen Listenelemente müssen dann auch diesen Typ haben, weil Listenelemente in Haskell gleichen Typ haben, also [ b -> b, b -> b, b -> b], wobei als Typangabe [b ->b ] reicht. h ist auf gleiche Weise wie f definierbar, also b->b.

[dvs]

g e h x = h (h(e x)) Lösung g :: (a -> b) -> (b -> b) -> a -> b

ich fange mit h(h(e x )) an. e x bildet z.B. a ->b ab, also x ist a, e ist a->b.
h muss dann b->c abbilden, wegen h(e x), aber wegen h(h(e x)) muss h den gleichen Eingabe und Rückgabetyp haben, also nicht b->c, sondern b->b.
Nun setzen wir ein: für e: a->b, für h: b->b, für x: a und ergebnis ist der Rückgabetyp von h, wegen h(h(e x)) auf der rechten seite, also auf b