www.jammni.de

1 2

Gepostet:
29.04.2010 17:47

Also wenn ich mich richtig erinnere sind First und Follow ja jeweils eine Menge von Wörtern bestehend aus Terminalsymbolen zu jedem Non-Terminal. Daher würde ich first und follow vom Typ :: Grammar -> [(Variable, [[Terminal]])] definieren, also für jedes Non-Terminal eine Liste von Terminal-Wörtern (ein Wort ist vom Typ [Terminal]).

Zum Seitenanfang

arnold74

Gepostet:
30.04.2010 15:18

danke,
werde am Wochenende versuchen mit der Aufgabe zu beginnen, in der Zwischenzeit danke

Zum Seitenanfang

arnold74

Gepostet:
04.05.2010 15:30

Verwenden der Datentypen vom Typ Grammar usw

Hallo ,
wie kann ich die Datentypen vom Typ Grammar in meinem Modul verwenden? Ich habe ein FirstFollow.hs erstellt und möchte nun den Typ für First definieren:
first :: Grammar -> usw. Muss ich zwingend alles nochmals definieren oder wie gehe ich vor? Ich darf leider nichts an Grammar.hs ändern. Habe ein Import qualified Grammar schon versucht! Ich möchte einfach zum Weiterverarbeiten auf diese Datentypen zugreifen.

danke
arnold

Zum Seitenanfang

arnold74

Gepostet:
04.05.2010 16:54

Bin wirklich ein blutiger Anfänger habe folgendes versucht:


module FirstFollow where
import qualified Grammar

first ::Grammar.Grammar -> [Grammar.Production]
first (Grammar.Grammar _ xs) = xs

test :: [Grammar.Production] -> [Grammar.Variable]
test (Grammar.Production var _) = var

Ich möcht einfach die Productions vom Typ Variable [Symbol] aufsplitten. In xs sollten ja alle Productions enthalten sein und nun möchte ich daraus eine Liste von Tuples erstellen [(Variable),[Symbol]]. Vielleicht kannst Du mir ja nochmals weiterhelfen Syracusa. Habe ein wenig gebastelt, wie muss ich die funktion test definieren?

danke
arnold

Zum Seitenanfang

Siracusa

Gepostet:
04.05.2010 17:40

Hallo,

deine imports sind richtig, soweit ich das sehe. Welchen Fehler bekommst du denn? Übrigens kannst du dir das "Grammar." vor den Bezeichnern sparen, wenn du statt "import qualified Grammar" nur "import Grammar" schreibst. Vorausgesetzt es gibt in zwei importierten Modulen keinen Bezeichner/Typ mit dem selben Namen. Und vorausgesetzt du willst das überhaupt :-)

Bei test sagst du in der Typsignatur, die Funktion soll eine Liste von Produktionen bekommen, in der Funktion machst du aber einen Musterangleich nur für eine einzelne Produktion. test würde dir also nur zu einer Produktion die Variable liefern. Wenn du eine Funktion auf eine ganze Liste anwenden willst, kannst du dazu die Funktion map benutzen, ist im Prelude definiert.

Viele Grüße,

Siracusa

Zum Seitenanfang

arnold74

Gepostet:
04.05.2010 19:52

Vielen Dank für deinen Import-Hinweis:
Habe nun folgendes für die Funktion Test:


module FirstFollow where
import Grammar

first ::Grammar -> [Production]
first (Grammar _ xs) = xs

test :: [Production] -> [(Variable,Symbol)]
test ([Production x xs]) = []

Wie kann ich nun genau für eine Liste von Production eine Aufsplittung erreichen so wie in der Typdeklaration angegeben oder würdest Du einen anderen Weg vorschlagen um die First-Menge zu erstellen. Habe es schon versucht mit
test ([Production x xs]) = (x,xs) - doch leider ohne Erfolg

danke Siracusa
EDIT:
Ok bin nun weiter. Ich habe nun folgendes:


module FirstFollow where
import Grammar

first ::Grammar -> [Production]
first (Grammar _ xs) = xs

test :: [Production] -> [(Variable,[Symbol])]
test ([Production x []]) =[ (x,[])]
test ([Production x xs]) =[ (x,xs)]

Sollte dies so passen? Leider ist mir nicht klar wie ich das testen soll. Wie muss ich main ändern um diese auf dem Bildschirm zu bekommen. Muss ich da dieses Monad-Konstrukt forM_ verwenden oder geht es einfacher. Siehe erstes Posting!
Habe einfache unter Main folgendes hinzugefügt


 forM_ (FirstFollow.test (Grammar.productions grammar)) (putStrLn . show)

Leider bekomme ich die Fehlermeldung: testmain: FirstFollow.hs:(8,0)-(9,34): Non-exhaustive patterns in function test
Aber jede Produktion hat ja einen NonTerminal auf der linken Seite, somit sollte test doch alle Pattern abdecken!
Vielen Dank für deine Geduld Siracusa (aller Anfang ist schwer :-) )
arnold

Zum Seitenanfang

Siracusa

Gepostet:
04.05.2010 21:22

> test ([Production x xs]) =[ (x,xs)]

Was du hier machst ist eine Musteranpassung an eine Liste, die nur ein Element (eine Produktion) enthält. Normalerweise wird die Liste mehr Produktionen enthalten und in diesem Falle scheitert die Musteranpassung.

> forM_ (FirstFollow.test (Grammar.productions grammar)) (putStrLn . show)

Das ist schon okay so.

Ich würde dir empfehlen ein Tutorial zu Haskell durchzuarbeiten, die IO-Sachen klappen ja schon ganz gut, beim Pattern matching bspw. gibt es aber offenbar noch Defizite. Zu empfehlen sind folgende Tutorials:
* http://www.haskell.org/tutorial/ - der Klassiker
* http://www.learnyouahaskell.com/ - etwas unkonventionell, aber ganz gut verständlich
* http://book.realworldhaskell.org/read/ - relativ kurze Einführung zu Haskell, hauptsächlich praktische Anwendung

Zum Seitenanfang

arnold74

Gepostet:
05.05.2010 08:29

Danke Siracusa,
habe diese Tutorials schon durchgearbeitet, leider scheint es als hätte ich noch Probleme mit Pattern Matching. Habe auch das Buch Programming in Haskell zugelegt von Graham Hutton (scheinbar ein Klassiker). Nun meine Frage :
bei den Beispielen im Internet und in meinem Buch sind die Pattern Matching auf Listen so angeführt:

function (n : ns) -> für eine Liste, aber leider ist n und ns nicht ein einfacher Datentyp sondern vom Typ Production. so alla Art function (Production x xs : Production y ys). vielleicht kannst Du mir ja einen Tipp geben, denn in den Beispielen von Pattern Matching auf Listen finde ich leider immer nur diesen von mir genannten Fall.

grüsse
Arnold

Zum Seitenanfang

Siracusa

Gepostet:
05.05.2010 14:53

Ja, das Buch von Hutton ist sehr zu empfehlen!

Also wenn du auf eine beliebige Liste matchen willst verwendest du [] für die leere Liste und (elem : rest) für das erste Element und die Restliste. Bei einer Produktion matcht du auf (Production x xs). Willst du nun z.B. die erste Produktion einer Liste von Produktionen, dann kombinierst du einfach beide Patterns: ( (Production x xs) : rest). rest ist dabei wieder die Restliste, es darf aber keine einzelne Produktion sein! Damit könntest du jetzt die Informationen aus der ersten Produktion in deiner Funktion verwenden und üblicherweise wird deine Funktion dann wieder rekursiv mit rest aufrufen, bis irgendwann der Fall [] matcht und die Rekursion endet.

Zum Seitenanfang

arnold74

Gepostet:
05.05.2010 15:39

danke in der ZwischenZeit, werde es gleich testen, ob es so nun funktioniert!

Zum Seitenanfang

vorherige Seite

1 2

Haskell-Forum