[HASKELL] Come utilizzare i Parser

[Neptune]

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]

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?