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


Autor ausgeben , das ist von mir geschrieben funktion, leider funktioniert es nicht.
data Autor = Autor { vorname:: String
, nachname:: String
} deriving (Show)

autorField:: Parser Autor
autorField = do
many space
anfangsTagOf \"td\"
nachname<- autor
endTagOf \"td\"
many space
return nachname

autor:: Parser Autor
autor = do
nachname<- buchstabe
oneOf \",\"
many space
vorname <- buchstabe
many space
return ( Autor vorname nachname)

buchstabe:: Parser String
buchstabe = do
buchstaben <- many1 digit -- warum bekomme ich beim letter html:Prelud.read: no parser letter ist doch für --buchstabenkännung
return (read buchstaben)

Vielen Dank im Voraus
VG
teo

Autor ausgeben , anfangsTagOf und EndTagOf habe auch als funktion bereits
so enliche Funktion habe ich für Datum auslesen geschrieben und die ist richtig ( <td class=td1 valign=top>23/05/12 ) bekomme ich Datum ausgegeben

das ist von mir geschrieben funktion, leider funktioniert es nicht.
data Autor = Autor { vorname:: String
, nachname:: String
} deriving (Show)

autorField:: Parser Autor
autorField = do
many space
anfangsTagOf \\\\\\\"td\\\\\\\"
nachname<- autor
endTagOf \\\\\\\"td\\\\\\\"
many space
return nachname

autor:: Parser Autor
autor = do
nachname<- buchstabe
oneOf \\\\\\\", \\\\\\\"
many space
vorname <- buchstabe
many space
return ( Autor vorname nachname)

buchstabe:: Parser String
buchstabe = do
buchstaben <- many1 digit -- warum bekomme ich beim letter html:Prelud.read: no parser --letter ist doch für buchstabenkännung
return (read buchstaben)

Vielen Dank im Voraus
VG
teo
Lix

Gepostet:
12.02.2010 11:50

Grundproblem mit Parsern  
Hi, Leute... hab schon länger im Internet gesucht nach einer Lösung für mein Problem, aber niemand scheint das Problem zu haben... vorab, ich bin noch Anfänger in Haskell...
also, ich bin grade dabei ein paar Grundparser zu programmieren, um Übungsaufgaben zu lösen, aber schon diese grundlegenden Parser funktionieren nicht:


type Parser a = String -> [(a, String)]

returnp :: a -> Parser a
returnp v = \inp -> [(v, inp)]

failure :: Parser a
failure = \inp -> []

item :: Parser Char
item = \inp -> case inp of
[] -> []
(x:xs) -> [(x,xs)]

parse :: Parser a -> String -> [(a, String)]
parse p inp = p inp

(>==) :: Parser a -> (a -> Parser b) -> (Parser b)
p >== f = \inp -> case parse p inp of
[] -> []
[(v, out)] -> parse (f v) out

(+++) :: Parser a -> Parser a -> Parser a
p +++ q = \inp -> case parse p inp of
[] -> parse q inp
[(v, out)] -> [(v, out)]

many :: Parser a -> Parser [a]
many p = many1 p +++ returnp []

many1 :: Parser a -> Parser [a]
many1 p = do v <- p
vs <- many p
returnp (v:vs)


Diese Teile hab ich mir nicht ausgedacht, sie waren gegeben, um bei den Übungsaufgaben zu helfen... GHCI nimmt sie aber nicht an.


Couldn't match expected type '[(a, String)]'
against inferred type '([a], String)'
Expected type : [[(a, String)]]
Inferred type: [([a], String)]
In the second argument of '(:)', namely 'vs'
In the first argument of 'returnp', namely '(v:vs)'


Hat jemand eine Idee? Die Sache ist, dass ich diese Definitionen auch auf allen möglichen Websiten finde, hab sie sogar mehrfach Zeichen für Zeichen abgetippt, dennoch kommt jedesmal ein dicker Fehler. Ich wäre dankbar für konstruktive Antworten.

LG Lix
Zum Seitenanfang    
 
Siracusa

Gepostet:
12.02.2010 14:18

   
Hallo,

das Problem liegt in der Funktion many1 (bei mir kommt jedoch ne andere Fehlermeldung). Dort steht v <- p, was man aber nur bei Monaden verwenden kann. Bei dir gibt es jedoch keine Monaden-Instanz für Parser. Du kannst daher auch die Funktion umformen:
many1 :: Parser a -> Parser [a]
many1 p = p >== \v -> many p >== \vs -> returnp (v:vs)

Dann hätte ich noch eine Bemerkung zur Funktion item. Die parst ein Zeichen vom String, egal welches. Sollte man da nicht noch angeben können, welches Zeichen geparst werden soll? Mit den momentanen Funktionen kann man m.E. noch keinen sinnvollen Parser zusammenbauen.


Viele Grüße,

Siracusa
Zum Seitenanfang    
 
Lix

Gepostet:
12.02.2010 15:07

   
Danke für deine Antwort. Kannst du vielleicht noch sagen, wie eine entsprechende Monaden-Instanz für Parser auszusehen hat? Bzw, ob es dafür vielleicht auch einfach einen Zusatz gibt, den man über import x dazuholen kann? So war es z.B. auch bei einer früheren Übung, bei denen Funktionen isDigit, isUpper, etc. einfach vorausgesetzt wurden, wobei aber nicht erwähnt wurde, dass import Char oben noch einzutragen ist. Dort hatte man nur ziemlich schnell gemerkt, dass was fehlt. Naja, wie auch immer. Zu deiner Frage: In der Tat, item parst wirklich jedes beliebige Zeichen von einem nichtleeren String. Du musst bedenken, dass das Thema Parser, Monaden und interaktive Programme noch ganz frisch bei uns ist. Deshalb weiß ich auch bei entsprechenden Fehlern schnell nicht mehr weiter, zumal ich auch meine Probleme mit diesen Lambda-Ausdrücken habe.
Es heißt, mit Hilfe von item, failure und returnp können wir uns alle Parser zusammensetzen, die uns auf diesem Niveau interessieren... für dich wahrscheinlich absoluter Urschleim, wie ich annehme.
Vielleicht habe ich später aus besagten Grunden ja noch eine Frage.

LG
Zum Seitenanfang    
 
Siracusa

Gepostet:
12.02.2010 15:22

   
Kannst du vielleicht noch sagen, wie eine entsprechende Monaden-Instanz für Parser auszusehen hat?
Theoretisch so:
instance Monad Parser where
return = returnp
(>>=) = (>==)

Allerdings bin ich nicht sicher, ob man für Typsynonyme überhaupt Instanzen angeben kann.


Es heißt, mit Hilfe von item, failure und returnp können wir uns alle Parser zusammensetzen

Da möchte ich fast das Gegenteil behaupten ;-)


Viele Grüße,

Siracusa
Zum Seitenanfang    
 
Lix

Gepostet:
12.02.2010 15:57

   
Könnte man da vielleicht mit dem Befehl newtype was machen? Frag nicht warum, aber ich meine ich hatte das in dem Zusammenhang irgendwo gesehen...

Nochmal danke, denn dank deiner Defition für many1 konnte ich jetzt auch andere Parser definieren, die zuvor auch alle in vorherigem Stil definiert wurden.
Ich denke, der Parser "sat" ist der, den du meintest. Für den konnte ich vorher zufällig eine andere Definition im Internet finden, denn auch der wurde in diesem "x <- p"-Stil definiert.

Zu dem anderen: Ich poste gleich nochmal meine bisherige Parser-Standard-Bibliothek. Item ist denke ich vorhanden aus Gründen der Herleitung und Erklärung, da es der erste Parser war, der überhaupt nach irgendeinem Kriterium entweder scheitert oder erfolgreich ist, und wenn dieses Kriterium nur darin besteht, ob der String leer oder nichtleer ist. Zuvor behandelte Parser waren nämlich nur returnp und failure, bei denen die Eingabe ja völlig belangenlos ist.


import Char

type Parser a = String -> [(a, String)]

returnp :: a -> Parser a
returnp v = \inp -> [(v, inp)]

failure :: Parser a
failure = \inp -> []

item :: Parser Char
item = \inp -> case inp of
[] -> []
(x:xs) -> [(x,xs)]

parse :: Parser a -> String -> [(a, String)]
parse p inp = p inp

(>==) :: Parser a -> (a -> Parser b) -> (Parser b)
p >== f = \inp -> case parse p inp of
[] -> []
[(v, out)] -> parse (f v) out

(+++) :: Parser a -> Parser a -> Parser a
p +++ q = \inp -> case parse p inp of
[] -> parse q inp
[(v, out)] -> [(v, out)]

sat :: (Char -> Bool) -> Parser Char
sat p = item >== \x -> if p x then returnp x else failure

digit :: Parser Char
digit = sat isDigit

lower :: Parser Char
lower = sat isLower

upper :: Parser Char
upper = sat isUpper

letter :: Parser Char
letter = sat isAlpha

alphanum :: Parser Char
alphanum = sat isAlphaNum

char :: Char -> Parser Char
char x = sat (== x)

string :: String -> Parser String
string [] = returnp []
string (x:xs) = char x >== \v -> string xs >== \vs -> returnp (v:vs)

many :: Parser a -> Parser [a]
many p = many1 p +++ returnp []

many1 :: Parser a -> Parser [a]
many1 p = p >== \v -> many p >== \vs -> returnp (v:vs)

ident :: Parser String
ident = lower >== \v -> many alphanum >== \vs -> returnp (v:vs)

nat :: Parser Int
nat = many1 digit >== \vs -> returnp (read vs)

space :: Parser ()
space = many (sat isSpace) >== \_ -> returnp ()


Die Bibo ist allerdings noch nicht vollständig, es folgen danach noch Parser zur weiterführenden Behandlung von Leerzeichen und Parser für Algebraische Ausdrücke.

LG
Zum Seitenanfang    
 
Siracusa

Gepostet:
12.02.2010 16:32

   
Mit newtype oder data würde es gehen. Allerdings müssten dann auch fast alle anderen Grundfunktionen angepasst werden. Vielleicht gibt's ne Möglichkeit, die Originaldefinition mit type zu behalten und die Monaden-Version von item, aber ich seh grad keine. :-(
Zum Seitenanfang    
 
teo

Gepostet:
05.04.2012 19:25

Daten Auslesen  
Hallo Zusammen, vielleicht kann mir bitte jemand helfen, muss aus der <td class=td1 valign=top>Mann, Thomas
Zum Seitenanfang    
 
IKT

Gepostet:
06.04.2012 11:39

   
Ist da etwas schief gegangen? Oberhalb des ersten Postings wird bei mir ein unformatierter Beitrag angezeigt , ist das deiner, Theo?
Zum Seitenanfang    
 
teo

Gepostet:
09.04.2012 13:58

   
Hallo IKT,

es ist tatsechlich schiff geagnegen, muss aus der <td class=td1 valign=top>Mann, Thomas
Zum Seitenanfang    
 
IKT

Gepostet:
09.04.2012 16:19

   
Ich würde gerne versuchen zu helfen, allerdings ist auch der 2. Beitrag irgendwie verstückelt worden.

Könntest du deine Beiträge vielleicht hier http://hpaste.org/ oder so nochmal posten und dann verlinken?
Zum Seitenanfang    
 

  1 2 nächste Seite