Playing aroud with Haskell State - haskell

Question

So I am trying to implement a Haskell game using the State and as a part of the game, I wanted to implement ways to save a current player's name and retrieve it when called. I have helper functions popStack and pushStack which pops and pushes values into stack respectively.
The current code:
import Control.Monad.State
data Gamestate = Gamestate {
gamestack :: [String],
gamememory :: String
}
type NewGameState = State GameState
popStack :: NewGameState String
popStack = state $ \st -> case gamestack st of
[] -> (0.0,st)
x:xs -> (x,st { gamestack = xs })
pushStack :: String -> NewGameState ()
push d = modify $ \st -> st { gamestack = d : gamestack st }
I have come up with the following code for saveName and getName.
saveName :: NewGameState ()
saveName = do
memory <-head
pushStack $ x
getName :: NewGameState ()
getName = do
memory <- head gamestack
popStack $ memory
The code snippets above return type errors. I don't understand State Monads much. So how do I copy the current players name at the top of the gamestack into gamememory using saveName and push the gamememory at the top of gamestack when I use getName?
Sorry if its a bit confusing. I am an ESL speaker. Thanks in advance.

Answer 1

I'm going to answer your question by showing you the idiomatic way to do what you are trying to do. As I go along I'm going to point out what I fixed in your code.
First problem: You have inconsistent capitalization of Gamestate. Capitalization matters in Haskell, so I renamed everything to GameState.
So after making that fixes, the first thing I did was define lenses to your two data type's fields. This makes it much easier do stateful things that modify a subset of your state. You will see this when I get to the implementations of the remaining functions:
import Control.Monad.State
import Control.Lens
data GameState = GameState
{ _gamestack :: [String]
, _gamememory :: String
}
gamestack :: Lens' GameState [String]
gamestack k (GameState s m) = fmap (\s' -> GameState s' m) (k s)
gamememory :: Lens' GameState String
gamememory k (GameState s m) = fmap (\m' -> GameState s m') (k m)
type NewGameState = State GameState
Note that you don't have to manually define lenses like this. Instead of defining gamememory and gamestack, you could also have done this instead:
{-# LANGUAGE TemplateHaskell #-} -- Note the extension
import Control.Lens
data GameState = GameState
{ _gamestack :: [String]
, _gamememory :: String
}
makeLenses ''GameState
Whichever way you choose, once we have these lenses, we can write push and pop in such a way that they don't care what state they are acting on, as long as it is a list:
pop :: State [a] (Maybe a)
pop = do
s <- get
case s of
[] -> return Nothing
x:xs -> do
put xs
return (Just x)
push :: a -> State [a] ()
push d = modify (d:)
Notice that I changed pop to return a Maybe if the list is empty. This is more idiomatic Haskell than defaulting to 0 or using head.
Using push and pop, it becomes very easy to transfer values between your game's memory and its stack:
saveName :: NewGameState ()
saveName = do
memory <- use gamememory
zoom gamestack (push memory)
getName :: NewGameState ()
getName = do
m <- zoom gamestack pop
case m of
Nothing -> return ()
Just x -> gamememory .= x
Notice how I use zoom to localize push and pop to operate on either the gamememory or the gamestack fields. zoom takes a lens to a sub-field and then runs the stateful action as if the entire state were just that sub-field. This is cool because now push and pop are much more reusable and we don't have to bake in a specific choice of state data type into them.
This also uses .=, which sets a given field. It's basically the same as:
lens .= x = zoom lens (put x)
To learn more about lenses, (.=), and zoom, you might want to read this post that I wrote.
Edit: By request, here is the lens-free version:
import Control.Monad.State
data GameState = GameState
{ gamestack :: [String]
, gamememory :: String
}
type NewGameState = State GameState
saveName :: NewGameState ()
saveName = do
GameState stack memory <- get
put (GameState (memory:stack) memory)
getName :: NewGameState ()
getName = do
GameState stack memory <- get
case stack of
[] -> put (GameState stack memory)
x:xs -> put (GameState xs x )

Answer 2

If something is on the right side of a <- than it has to be in that monad. So what you want here is something like
saveName :: NewGameState ()
saveName = do
memory <- fmap gamememory get
pushStack memory
getName = popStack
for saveName we fmap gamememory over the current state and store the result in memory than push that on the stack. We can actually write this as get >>= pushStack . gamememory if you want to be fancy.
popStack doesn't take any arguments so I'm not sure what you wanted there. My best guess is that it should just grab the last name we pushed on which just is a call to popStack.

Answer 3

NewGameState is a poor name - it isn't a new game state at all, it's a monad that carries around a state. I just called it Game.
pushStack vs push - You gave a signature named pushStack then a function named push. Pick one.
In popStack you have [] -> (0.0, st) Let's face it, 0.0 is not a string, so why are you trying to return it? Did you just not know what to do when popping an empty stack? How about you use "" instead?
saveName and getName Well you haven't even said what you want these to do. It seems you accepted other answerer's interpretations so going with that, we can just use record update syntax.
In the end, here is some code that at least compiles:
import Control.Monad.State
data GameState = GameState {
gamestack :: [String],
gamememory :: String
}
type Game = State GameState
popStack :: Game (Maybe String)
popStack = state $ \st -> case gamestack st of
[] -> (Nothing,st)
x:xs -> (Just x,st { gamestack = xs })
pushStack :: String -> Game ()
pushStack d = modify $ \st -> st { gamestack = d : gamestack st }
saveName :: Game ()
saveName = do
memory <- gamememory `fmap` get
pushStack memory
getName :: Game ()
getName = do
newMem <- popStack
case newMem of
Nothing -> return ()
Just n -> modify (\x -> x { gamememory = n } )