Tłumaczenie z monada na aplikacyjny

Question

OK, więc wiem, co zawiera klasa typu Applicative i dlaczego jest to przydatne. Ale nie jestem w stanie opisać, w jaki sposób używałbyś tego w nie nietrywialnym przykładzie.

Rozważmy na przykład następujący dość prosty parsec parsera:

integer :: Parser Integer 
integer = do 
    many1 space 
    ds <- many1 digit 
    return $ read ds 

Teraz jak do cholery chcesz napisać, że bez użycia instancji Monad dla Parser? Wiele osób twierdzi, że można to zrobić i jest to dobry pomysł, ale nie wiem, jak dokładnie.

Answer 1

integer :: Parser Integer 
integer = read <$> (many1 space *> many1 digit) 

Albo

integer = const read <$> many1 space <*> many1 digit 

Czy uważasz, albo z nich są bardziej czytelne jest do ciebie.

Answer 2

bym napisać

integer :: Parser Integer 
integer = read <$ many1 space <*> many1 digit 

Jest grono wiązanie lewe (jak aplikacji) Operatorzy parser-budowlanych <$>, <*>, <$, <*. Rzecz po lewej stronie powinna być czystą funkcją, która składa wartość wyniku z wartości składowych. Rzecz po prawej stronie każdego operatora powinna być parserem, zbiorowo podając elementy gramatyki od lewej do prawej. Wybór operatora zależy od dwóch opcji, jak następuje.

the thing to the right is signal/noise 
    _________________________    
    the thing to the left is \   
          +------------------- 
        pure/| <$>  <$ 
        a parser | <*>  <* 

Tak, wybrawszy read :: String -> Integer jako czystej funkcji, która ma zamiar dostarczyć semantykę parsera, możemy sklasyfikować główną przestrzeń jako „szum”, a bandą cyfr jako „sygnał”, stąd

read <$ many1 space <*> many1 digit 
(..) (.........)  (.........) 
pure noise parser  | 
(.................)  | 
    parser    signal parser 
(.................................) 
        parser 

można łączyć wiele możliwości z

p1 <|> ... <|> pn 

i wyraźnej niemożności z

empty 

Rzadko trzeba nazwać komponenty w analizatorach składni, a wynikowy kod wygląda bardziej jak gramatyka z dodaną semantyką.

Answer 3

Twój przykład można stopniowo przepisany do postaci, która wyraźniej przypomina aplikacyjnych:

do 
    many1 space 
    ds <- many1 digit 
    return $ read ds 

1. definicji do notacji:

   many1 space >> (many1 digit >>= \ds -> return $ read ds) 
   

2. definicja $:

   many1 space >> (many1 digit >>= \ds -> return (read ds)) 
   

3. definicja .:

   many1 space >> (many1 digit >>= (return . read)) 
   

4. prawo 3-te monada (asocjatywność):

   (many1 space >> many1 digit) >>= (return . read) 
   

5. definicja liftM (w nie- do notacji):

   liftM read (many1 space >> many1 digit) 
   

To jest (lub powinno być, jeśli nie zawiodłem :)) identyczne zachowanie do twojego przykładu.

Teraz, jeśli zastąpić liftM z fmap z <$> i >> z *>, ty dostać aplikacyjnych:

read <$> (many1 space *> many1 digit) 

Jest to ważne, ponieważ liftM, fmap i <$> są generalnie ma być synonimami, jak są >> i .

To wszystko działa i możemy to zrobić, ponieważ oryginalny przykład nie użył wyniku żadnego parsera do zbudowania następującego parsera.