在Haskell中使用状态Monad和'put'功能

Question

The Documentation about the State Monad says:

 put :: s -> m () 

Replace the state inside the monad.

I cannot understand that. Does it mean that function replace state inside Monad? And The second issue: Why returned value is m () and not ms

Answer 1

The easiest way to understand the state monad, I think, is just to write your own and play around with it a bit. Study this code, play with other people's examples, and come back and review it from time to time until you're able to write it from memory:

-- | 'State' is just a newtype wrapper around the type @s -> (a, s)@.
-- These are functions which are fed a state value (type @s@) as input,
-- and produce as a pair of an @a@ (the *result* of the state action)
-- and an @s@ (the *new state* after the action).
--
-- The 'State' type is fundamentally a shortcut for chaining functions
-- of types like that.
newtype State s a = State { runState :: s -> (a, s) }

instance Functor (State s) where
  fmap f (State g) = State $ \s0 -> 
      let (a, s1) = g s 
      in (f a, s1)

instance Applicative (State s) where
  pure a = State $ \s -> (a, s)
  State ff <*> State fa = State $ \s0 -> 
      let (s1, f) = ff s0
          (s2, a) = fa s1
      in (s2, f a)

instance Monad (State s) where
  return = pure
  State fa >>= f = State $ \s0 ->
      let (s1, a) = fa s0
          (s2, b) = runState (f a) s1
      in (s2, b)

-- | 'get' is just a wrapper around a function that takes the 
-- incoming @s@ value and exposes it in the position where @a@ 
-- normally goes.
get :: State s s
get = State $ \s -> (s, s)

-- | 'put' is a wrapper around a function that discards the
-- the incoming @s@ value and replaces it with another.
put :: s -> State s ()
put s = State $ \_ -> ((), s)

This is written directly in terms of a State type without using the MonadState class, which is a bit simpler to understand at first. As an exercise, once you feel comfortable with this, you can try writing it with the MonadState class.

And the second issue: Why returned value is m () and not ms ?

It's mostly an arbitrary design choice, as far as I can tell. If I were designing the State type I might have written get and put like this, which is more similar to your expectation:

-- | Modify the incoming state by applying the given function to it.
-- Produces the previous, now discarded state as a result, which is 
-- often useful.
modify :: (s -> s) -> State s s
modify f = State $ \s0 -> (s, f s)

-- Now 'get' and 'put' can be written in terms of 'modify':

get :: State s s
get = modify (\s -> s)

-- | This version of 'put' returns the original, discarded state,
-- which again is often useful.
put :: s -> State s s
put s = modify (\_ -> s)

If you have the standard 'get' and 'put' you can use that to write my modified 'put' as well:

-- | 'get' the incoming state, 'put' a new one in, and 'return' the old one.
replace :: s -> State s s
replace s1 = do
  s0 <- get
  put s1
  return s0

So it doesn't make a big difference whether put produces () or s , anyway.