Verwenden Sie zwei Monaden ohne Transformator

Question

Um zu verstehen, wie man Monad-Transformatoren verwendet, schrieb ich den folgenden Code ohne einen. Es liest die Standardeingabe Zeile für Zeile und zeigt jede Zeile umgekehrt an, bis eine leere Zeile gefunden wird. Es zählt auch die Zeilen mit State und zeigt am Ende die Gesamtzahl an.

import Control.Monad.State 

main = print =<< fmap (`evalState` 0) go where 
    go :: IO (State Int Int) 
    go = do 
     l <- getLine 
     if null l 
     then return get 
     else do 
      putStrLn (reverse l) 
      -- another possibility: fmap (modify (+1) >>) go 
      rest <- go 
      return $ do 
       modify (+1) 
       rest 

Ich wollte die aktuelle Zeilennummer vor jeder Zeile hinzufügen. Ich war in der Lage, es zu tun mit StateT:

import Control.Monad.State 

main = print =<< evalStateT go 0 where 
    go :: StateT Int IO Int 
    go = do 
     l <- lift getLine 
     if null l 
     then get 
     else do 
      n <- get 
      lift (putStrLn (show n ++ ' ' : reverse l)) 
      modify (+1) 
      go 

Meine Frage ist: wie man das gleiche in der Version ohne Monade Transformatoren zu tun?

Answer 1

Sie müssten nur die akkumulierte Zustandsberechnung in jeder Zeile ausführen. Das ist O (n²) Zeit, aber da Ihr erstes Programm bereits O (n) Raum verwendet, ist das nicht zu schrecklich. Natürlich ist der StateT Ansatz in fast jeder Hinsicht überlegen! Wenn Sie es wirklich "von Hand" machen und keinen Effizienzpreis zahlen wollen, verwalten Sie den Staat einfach per Hand, anstatt einen staatlichen Transformator zu bauen. Sie erhalten wirklich keinen Vorteil, indem Sie State anstelle von Int im ersten Programm verwenden.

Answer 2

Vielleicht suchen Sie das?

main = print =<< fmap (`evalState` 0) (go get) where 
    go :: State Int Int -> IO (State Int Int) 
    go st = do 
    l <- getLine 
    if null l 
    then return (st >>= \_ -> get) 
    else do 
      let ln = evalState st 0 
      putStrLn(show ln ++ ' ' : reverse l) 
      go (st >>= \_ -> modify (+1) >>= \_ -> get) 

Die Idee hier ist go Schwanz rekursiv zu machen, Ihren Zustand Berechnung Aufbau, die Sie bei jedem Schritt dann auswerten können.

EDIT

Diese Version wird die Größe des Staates Berechnung auf eine konstante Größe gebunden, obwohl unter lazy evaluation, wenn der vorherige Zustand Berechnung gezwungen wird, sollten wir in der Lage sein, es wieder zu verwenden, ohne neu zu bewerten es, so vermute ich, dass diese im wesentlichen die gleichen ...

main = print =<< fmap (`evalState` 0) (go get) where 
    go :: State Int Int -> IO (State Int Int) 
    go st = do 
    l <- getLine 
    if null l 
    then return st 
    else do 
      let ln = evalState st 0 
      putStrLn(show ln ++ ' ' : reverse l) 
      go (modify (\s -> s+ln+1) >>= \_ -> get) 

Answer 3

das Problem, das Sie ist sind mit, dass die Hand-Abrollen des StateT s IO as -> IO (s, a) ist, nicht IO (s -> (s, a))! Sobald Sie diesen Einblick haben, ist es ziemlich einfach zu sehen, wie es geht: