PDA

Visualizza la versione completa : [HASKELL] Come utilizzare i Parser


Neptune
29-10-2011, 17:13
Salve a tutti,
l'altro giorno sulla lezione dei parser mi sono letteralmente perso, forse anche per via delle slide della lezione molto stringate. Sapreste darmi qualche link o qualche dritta su cosa sono e come utilizzare i parser in Haskell ?

Certamente so cos'è a grossi linee un parser, ma semplicemente non riesco a capire cosa sono e a cosa servono queste funzioni parser in Haskell.

Ad esempio questo codice, sarebbe l'equivalente di un typdef del C? come lo dovrei interpretare?



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



Questa funzione qui, sopratutto il tipo, come va interpretata? Cioè qui "Parser" sembra più una funzione che un tipo. Ma allora Type a cosa serve? e la prima riga di qui sotto cosa fignifica? Oppure vuol significare di sostituire Char al posto di a nel tipo Parser? (e quindi sono una specie di java generics?)



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


Addirittura alla fine le combina le due scrivendo



Parser item "abc"


So di avere le idee un pò confuse ed il problema è proprio questo.

Vi ringrazio in anticipo,
Neptune.

Neptune
30-10-2011, 14:21
Restringo la domanda, ovvero i dubbi:

- leggevo, nella definizione di parser il seguente codice:


> newtype Parser a = P (String -> [(a,String)])

Cioè Parser è un tipo? una specie di typedef del C? ovvero quando leggo Parser deve significare che c'è una certa funzione P che data una Stringa mi ritorni quella lista?

Quindi per questo ho bisogno di una funzione parse per applicare una funzione di parser ad una stringa:


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

Ovvero parse va interpretata come una funzione che presi in input una funzione P del tipo (String -> [(a,String)]) e presa una stringa mi applica la funzione P alla stringa ritornandomi quindi la lista [(a,String)] ?
Quindi detto in poche parole noi abbiamo sia Parse che parser solo per rendere più leggibile il codice?

Ad esempio se prendiamo il parser item

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

Questo ci dice che è una funzione parser sostituisce nel "newtype" a con char e ci dice che preso in input una stringa ci restituisce una stringa del tipo [(char,String)]) ?
Però a questo punto mi sfugge perchè per eseguirla devo darla in input alla funzione parse. Probabilmente (anzi sicuramente) mi sfugge l'esatto significato di:


> newtype Parser a = P (String -> [(a,String)])

O più precisamente della parte a destra, ovvero:


P (String -> [(a,String)])

Per il resto il funzionamento su carta dei parser l'ho capito, quello che mi sfugge sostanzialmente è il significato che Hugs, quindi Haskell, da a Parser e a parse.

Forse è che mi sfugge cos'è una monade e nelle slide viene detto che Parser è una monade, qualcuno saprebbe darmi una definizione semplice della cosa?

Loading