Qualcuno può guidarmi attraverso questa funzione di Haskell (relativa alla monade di stato)?

Question

tick :: State Int Int 
tick = get >>= \n -> 
     put (n+1) >>= \y -> 
     return n 

Sono confuso su come put (n+1) abbia alcun effetto sul risultato finale di questa funzione. Sembra che questa funzione dovrebbe restituire lo stato iniziale invariato. Sto provando a ripercorrere questo nella mia mente, ma continuo a correre fuori dalla stanza per tenere le cose a posto. : \

Se qualcuno mi poteva camminare attraverso la valutazione di questa funzione, sarebbe davvero utile.

Answer 1

... Come si aggiorna lo stato in primo luogo? Sembra stia seduto lì senza far nulla ...

Ah, ora capisco la tua domanda. Ti stai chiedendo come funziona il put (e get), giusto?

Forse un esempio in JavaScript aiuterà (una lingua con stato mutevole reale):

var s; // mutable state 
function get() { return s; } 
function put(x) { s = x; } 

function tick() { 
    var n = get(); 
    put(n + 1); 
    return n; 
} 

Spero che questo dimostra che, mentre n non cambia, lo stato interno ancora viene aggiornata. Se si esegue tick() due volte, lo stato verrà incrementato due volte.

di tornare a Haskell, ecco la definizione completa di (parti rilevanti) del State Monade:

newtype State s a = State { runState :: s -> (a, s) } 

instance Monad (State s) where 
    return a = State $ \s -> (a, s) 
    m >>= k = State $ \s -> let 
     (a, r) = runState m s 
     in runState (k a) r 

get = State $ \s -> (s, s) 
put s = State $ \_ -> ((), s) 

Ora provate a espandere la vostra tick esempio ulteriormente inlining manualmente >>=, return, get e put. Speriamo che diventi più chiaro come funziona lo Stato.

Answer 2

Hai perfettamente ragione. Il "risultato" della "funzione" tick è il valore iniziale dello stato.

Ovviamente, tick non è la vera "funzione", ma un calcolo che può leggere e scrivere stato prima di produrre un risultato.
In questo caso, lo stato di è aggiornato, ma si sta ancora restituendo il valore originale dello stato:

-- 4 is the inital state 
ghci> runState tick 4 
(4, 5) 
-- 4 is the result of the tick computation, 5 is the updated state 

In questo caso, dal momento che non si è mai ispezionare di nuovo lo stato interno tick, è Non vedo lo stato cambiato. Tuttavia, se qualche altro calcolo avviene dopo tick, può vedere lo stato aggiornato.

Per esempio, facendo tick due volte (la seconda leggerà lo stato aggiornato):

-- 4 is the inital state 
ghci> runState (tick >> tick) 4 
(5, 6) 
-- 5 is the result of the tick computation executed twice, 
-- 6 is the updated state 

Answer 3

potrebbe aiutare a scrivere utilizzando do notazione

tick :: State Int Int 
tick = do 
    n <- get -- get the state 
    put (n+1) -- save an incremented state 
    return n -- return the original state 

mentre il put (n+1) non lo fa impatto il risultato del calcolo, altera lo stato che si tiene all'interno della monade di stato.