www.jammni.de

Logo - Kleiner Drache
Login
Username:

Passwort:

Daten merken
Auto-Login
Registrieren
 
Online
niemand
 
Forumsuche
Suche nach:

Logo - DracheHaskell-Forum

  1 2 nächste Seite

paco89

Gepostet:
23.02.2012 18:57

Typen in Haskell  
hallo, hab folgende frage versucht zu lösen. hab aber verständnisprobleme:


f [] x y =y
f [x:xs] y z = f [] (x:y) z


a) bestimmen sie zu der folgenden Haskell-funktion f den allgemeinsten Typ. geben sie den typ an und begründen sie ihre antwort.

nun ich muss sagen, dass ich die musterlösung von dieser aufgabe habe, aber daraus werde ich nicht schlau:

also die musterlösung lautet wie folgt:

1) Beginne mit allgemeiner definition : a->b->c->d

2) Aus der ersten Definition geht hervor, dass der Typ des 3. Arguments gleich ist mit dem typ des rückgabewerts. also c=d.

3) Aus der 2. Definition weiß man, dass der Typ des 1. Arguments eine Liste von Listen ist. Hat also das daraus entnommen x den Typ e . Also das 1. argument den Typ [[e]]

4) aus der 2. definition geht weiterhin hervor, dass x in y eingefügt werden. somit hat das 2. argument den typ [e].


Insgesamt ergibt sich Typ f :: [[e]] -> [e] -> c -> c


nun meine fragen dazu:

zu 1) hier ist alles klar. gar keine frage.

zu 2) hier ist auch alles klar. y=y also c=d

zu 3) hier beginnen schon die probleme: woher weiß man denn genau, dass der Typ des 1. Arguments eine Liste von Listen ist? soweit ich weiß stellt (x:xs) doch nur eine liste dar. wie kommen die darauf, dass es eine liste von listen ist? warum ein x jetzt daraus entnommen wird versteh ich auch nicht.

zu 4) warum x in y eingefügt werden kann, kan ich mir schon denken. das ist doch wegen (x:y) , nicht wahr? aber auch hier taucht das mit dem typ[e] auf, was mich verwirrt.




über eine antwort würde ich mich echt freuen. danke schon ma im voraus.



lg
Zum Seitenanfang    
 
Landei

Gepostet:
23.02.2012 20:18

   
Die Erklärungen sind wirklich ziemlich spartanisch, dabei ist es enorm wichtig, dass man das sicher beherrscht, sonst hängt einem später nur noch der Wunderbeutel um...

3) [bla] ist das Pattern für eine Liste mit einem Element. Nun ist das bla hier gleich x:xs, was ebenfalls eine Liste ist - also haben wir eine Liste in einer Liste. Du hast wahrscheinlich das erste Element als (x:xs) missgelesen (was ja auch wesentlich häufiger vorkommt)
4) Wenn das erste Element etwas wie [[e]] ist (wie wir aus 3. wissen), dann hat x den Typ e, und wenn dieses x in eine Liste eingefügt wird (was ja bei (x:y) passiert), hat diese Liste logischerweise den Typ [e]. Das eigentliche y spielt dabei im Prinzip keine Rolle, sondern nur die Tatsache, dass es auf der rechten Seite eines Doppelpunkts steht, es sich also um irgendeine Liste handelt.
Zum Seitenanfang    
 
paco89

Gepostet:
23.02.2012 21:02

   
ah, wunderbar...danke. jetzt ist einiges klarer geworden...;)

bei 1) habe ich wirklich [x:xs] als (x:xs) gelesen...in meinen unterlagen stand auch dass die eckigen klammmern und die notation x:xs eine liste darstellen.



nochmal vielen dank...;)
Zum Seitenanfang    
 
paco89

Gepostet:
24.02.2012 11:20

   
ich habe hier jetzt noch ne aufgabe bearbeitet, bei der ich wieder nicht weitergekommen bin :


g x 1 = 1

g x y = (\\x -> (g x 0)) y





so, ich beginne wieder mit einer generellen definition:

a-> b-> c

1) aus der ersten definition geht hervor, dass der typ des 2. arguments ein Int ist, da auf 1 gematcht wird. also b = Int

2) ich weiß auch, dass der typ des rückgabewerts ein Int sein muss, da 1 ein Integer ist. also c=Int.

3) so und was ich aus der 2. defintion gewinnen kann, weiß ich nicht. ich weiß zwar, dass \\x -> (g x 0) als \"Lambda-funktion\" bezeichnet wird, aber ich verstehe nicht wie das gemeint ist. was macht diese definition? in meiner musterlösung steht, dass (\\x -> (g x 0)) y = g y 0
aber wie kommen die darauf? und dann wird gesagt, dass der typ des 1. arguments den typ des 2. arguments haben muss.

wenn ich dass mit der lambda notation verstehen würde, würde ich den letzten teil der lösung auch verstehen.



über eine antwort würde ich mich freuen.



lg
Zum Seitenanfang    
 
Landei

Gepostet:
24.02.2012 11:30

   

g x 1 = 1

g x y = (\\x -> (g x 0)) y


..kannst du übersetzen in ...


g x 1 = 1

g x y = meineLambdaFunktion y

meineLambdaFunktion z = g z 0


Wichtig zu erkennen ist, dass das x in der Lambdafunktion ein anderes ist als das Argument x (es \"überdeckt\" es sozusagen), deshalb habe ich ersteres auch in z umbenannt.

Ich denke, so solltest du das Problem lösen können.
Zum Seitenanfang    
 
paco89

Gepostet:
24.02.2012 11:44

   
hmhh...also so sieht´s auf jeden fall deutlicher aus. ich vermute mal, dass es deshalb g y 0 ist, weil das argument y an 2. stelle steht. da in z = g z 0 auch das argument z an 2. stelle steht, darf ich das dann durch das y ersetzen, oder wie?
also wenn ich das so richtig verstanden habe, kommen die dann so auf g y 0. nun haben wir ja quasi (wenn ich das mal so salopp sagen/schreiben darf) eine andere funktion mit g y 0 und hierbei ist das y an 1.stelle, sodass das y den typ des 1. arguments bekommt, weil es ja jezt auch an 1. stelle steht.


ist das richtig so?
Zum Seitenanfang    
 
Landei

Gepostet:
24.02.2012 14:37

   
Ich denke, ja.

Erst einmal ist jetzt klar, dass die zweite Zeile im Endeffekt zu


g x y = g y 0


wird. Da y einmal als zweites und einmal als erstes Argument steht, müssen die Typen für beide Argumente gleich sein.
Zum Seitenanfang    
 
paco89

Gepostet:
24.02.2012 16:28

   
danke. jetzt kann ich das auch. ich hab weiter gemacht und weitere aufgaben gelöst, darunter war ein aufgabentyp, den ich noch nicht hatte. mit datenkonstruktoren usw. also dieser hier:


data T a = C1 | C2 a (T a)

i(x:xs) = C2 x (i xs)

i [] = C1



hmh... nun ja begonnen habe ich wieder mal mit einer generellen definition i:: a->b
aus der 1.Definition geht ja hervor, dass das 1. argument vom typ her eine liste sein muss. also gilt a = [e].
nun ja, was ich zum typ des rückgabewerts sagen sollt, wusste ich nicht. also habe ich in die musterlösung geschaut und da stand drin, dass der Typ des Rückgebawerts vom Typ T d ist, da der Konstruktor C2 verwendet wird. nun muss das erste argument von C2 (also x) den typen d haben. also gilt d =c

insgesamt gelte somit [e] -> T c


nun meine frage: woher wissen, dass sie jetzt T d als typ für den rückgabewert benutzen müssen? ist das wegen data T a ? und die benutzen doch d statt a weil wir a schon verwendet haben, oder?

Zum Seitenanfang    
 
Landei

Gepostet:
24.02.2012 17:03

   
i hat den Typ [e]. Dann hat x den Typ e. Wenn x im Konstruktor C2 an der Stelle verwendet wird, die in der Definition mit a belegt ist, dann muss der Konstruktor den Typ T e zurückliefern. Das zweite Argument, dass ja dann den Typ T e haben muss, passt auch, genauso wie die zweite Definition von i. Also haben wir i :: [e] -> T e
Zum Seitenanfang    
 
paco89

Gepostet:
24.02.2012 17:10

   
ah, okay. danke...kann das jetzt nachvollziehen.
Zum Seitenanfang    
 

  1 2 nächste Seite