Bug in Control.Monad.State

[Yitzchak Gale]

> ...I did not understand the example you posted,
> as it contains functions that are not defined...

Sorry. I actually think you understood it quite
well, from what you wrote in reply. But OK, I will
put in some more annotation below.

> but here is something you can do (...using
> monadLib...).  Letme know if this helps.

Well, I like using infinite lists - where a
sequence is completely decoupled from its end
conditions - as opposed to while-loop-like
constructs. And other such lazy paradigms when
appropriate. And I also like using monads when
they make my code more clear - which is usually.

And I like using these things together when they
happen to coincide. I gave Udo an example of a
common kind of situation in which that happens.

You wrote that you introduced some limited kind of
strictness in your state monad. My question was:
Can I still use infinite lists and state monads
together in monadLib?  I think your answer is
"No." Am I correct?

Regards,
Yitz

Iavor's code:

> import Monad.StateT
> import Monad.Id
> import Random
> 
> type M        = StateT (StdGen,[Int]) Id
> 
> randomItem   :: M ()
> randomItem    = do (g,xs) <- peek
>                    let (x,g') = random g
>                    poke_ (g',mod x 5 : xs)
> 
> needMoreItems :: M Bool
> needMoreItems = do (_,xs) <- peek
>                    return (sum xs < 50)
> 
> whileM p b    = do x <- p
>                    if x then b >> whileM p b else return ()
> 
> test          = do g <- newStdGen
>                    print $ runId $ evalState (g,[])
>                                  $ do whileM needMoreItems randomItem
>                                       (_,xs) <- peek
>                                       return xs

My code (that I wrote to Udo), with additional annotation:

import System.Random
import Control.Monad.State

createItems :: RandomGen g => State g [Item]
createItems =
  liftM catMaybes $ runListT $
  flip evalStateT initialState $ runMaybeT $
  do
    item <- liftRandom $ repeatM randomItem
    updateState item
    needMoreItems >>= guard
    return item
  where
    liftRandom = lift . lift . lift

-- The type of the items we need to create.
type Item = Int

-- Create one random item.
randomItem :: RandomGen g => State g Item
randomItem = State $ randomR (1, 5)

-- The type of the state we need to keep while
-- computing whether we have enough items yet.
type MyState = Int

-- The initial state while computing whether we
-- have enough items yet.
initialState :: MyState
initialState = 0

-- Update the state after creating an Item.
updateState :: MonadState MyState m => Item -> m ()
updateState = modify . (+)

--Do we need any more items?
needMoreItems :: MonadState MyState m => m Bool
needMoreItems = gets (< 50)

-- repeatM is still missing from Control.Monad.
-- I hope they will put it in soon.
repeatM :: Monad m => m a -> m [a]
repeatM = sequence . repeat

-- MaybeT is still missing from mtl.
-- I hope they will put it in soon.
newtype MaybeT m a = MaybeT {runMaybeT :: m (Maybe a)}
instance Monad m => Monad (MaybeT m) where ...
instance Monad m => MonadPlus (MaybeT m) where ...
instance MonadState s m => MonadState s (MaybeT m) where ...