[Haskell-cafe] monad question

[Andrew Harris]

Hi everyone,

  Well, I'm trying to build a soccer server client and am using
Haskell.  I thought I was muddling through well enough... but I have
some questions.  I am using the Robot monad that I copied from Hudak's
book HSOE from page 272 (assuming I would understand it later).

Here's the monad code I copied:

newtype Robot a = Robot (RobotState -> IO (RobotState, a))

instance Monad Robot where
        return a = Robot (\s -> return (s, a))
        Robot sf0 >>= f =
              Robot (\s0 -> do
                               (s1, a1) <- sf0 s0
                               let Robot sf1 = f a1
                               (s2, a2) <- sf1 s1
                               return (s2, a2))

updateState :: (RobotState -> RobotState) -> Robot ()
updateState u = Robot (\s -> return (u s, ()))

queryState :: (RobotState -> a) -> Robot a
queryState q = Robot (\s -> return (s, q s))

I defined myself a comfortable "chunk of state" (comfortable for today
at least):

data RobotState =
    RobotState { player_type :: RobotType,
                 team_name :: String,
                 my_current_position :: Position,
                 visible_flags :: [ObjInfo],
                 visible_ball :: [ObjInfo],
                 visible_friends :: [ObjInfo],
                 visible_foes :: [ObjInfo],
                 audible_player_messages :: [String],
                 my_current_mode :: RobotMode,
                 debug_level :: [RobotDebugLevel],
                 my_uniform_number :: Integer,
                 game_mode :: GameMode,
                 game_clock :: Integer } deriving Show

In addition, I added some support functions similar to the ones he
wrote in Section 19.3.1:

assign_flags :: [ObjInfo] -> Robot ()
assign_flags flaglist = updateState (\s -> s {visible_flags = flaglist})

assign_friends :: [ObjInfo] -> Robot ()
assign_friends friendlist = updateState (\s -> s {visible_friends = friendlist})

assign_foes :: [ObjInfo] -> Robot ()
assign_foes foelist = updateState (\s -> s {visible_foes = foelist})

assign_ball :: [ObjInfo] -> Robot ()
assign_ball balllist = updateState (\s -> s {visible_ball= balllist})

Now, I read several online monad tutorials and kind of understand the
notion of a thread of function calls.  And I know that the do notation
is syntactic sugar for the bind operation.  But the code I've written
is really nasty.  For example, here is part of my code that handles a
see record and returns a new RobotState:

handleSeeRecord :: [SeeObjInfo_type] -> RobotState -> IO (RobotState, ())
handleSeeRecord seeobjlist p = do flaglist <- return (morphToList
flagFinder seeobjlist)
                                 balllist <- return (morphToList
ballFinder seeobjlist)
                                 friendlist <- return (morphToList
friendFinder seeobjlist)
                                 foelist <- return (morphToList
foeFinder seeobjlist)
                                 Robot e <- return (assign_flags
(flagSpread flaglist))
                                 Robot f <- return (assign_ball balllist)
                                 Robot g <- return (assign_friends friendlist)
                                 Robot h <- return (assign_foes foelist)
                                 (r', ()) <- e p
                                 (r'', ()) <- f r'
                                 (r''', ()) <- g r''
                                 h r'''

This actually works, but I think it can be improved with the bind
operation >>= somehow.  I tried a few alternatives but couldn't find
one that worked.  I ended up with this because it seems I had to
"strip" the type off of "return (assign_flags (flagSpread flaglist))"
and get the "e" that was a function.  Might someone have a suggestion
on how to improve this?

thanks
-andrew