8

I have an algorithm that operates on an IntMap that I feel would best be expressed imperatively. That is, I'd like to say things like:

  • Look for value X in the map.
  • If it matches a criteria, remove this value from the map.
  • Loop until no more values exist in the map.

This would be fairly trivial to express as a two-line recursion, but the actual algorithm is a little more complex, involving several lookups and deletions, so I'd like to be able to express it in do notation.

Is there a standard "State"-like monad where the state is represented by Data.Map or Data.IntMap, where I can do something like:

do
  insert 5 20
  (ma, mv) <- lookup 4
  case mv of
    Just v -> delete (fromJust ma)
    Nothing -> return ()

Honestly I'm not sure how to best express this.. due to lookup it would seem to benefit from some kind of MaybeT IntMap m stack or something.

I did do a bit of work trying to define my own state monad based on Data.IntMap, even got as far as making insert and delete work, but got a little stuck with how to deal with lookup. Mostly i feel like this is probably something someone has already solved, but I can't find it on Hackage.

Steve
  • 8,153
  • 9
  • 44
  • 91

1 Answers1

23

Is there any particular reason you want to avoid using monad transformers? if you get the MaybeT package from Hackage you can achieve what you want like this:

import Control.Monad
import Control.Monad.Maybe
import Control.Monad.State
import qualified Data.Map as Map

type MapM k v a = MaybeT (State (Map.Map k v)) a

lookupM k = MaybeT $ Map.lookup k `liftM` get
insertM k = modify . Map.insert k
deleteM k = modify $ Map.delete k

runMap m = (flip execState) m . runMaybeT

foo = runMap Map.empty $ do
    insertM 5 20
    v <- lookupM 4
    deleteM v

When lookupM fails the rest of the computation fails. You can enter and escape these monads at any time so you can hide these under a pure function interface, it's only the IO monad that you not suppose to escape out of except in main (and using unsafe functions).

All you need to remember is any state action that returns Maybe type just lift into the MaybeT constructor. If you want to do IO change State to StateT.

snk_kid
  • 3,457
  • 3
  • 23
  • 18
  • Wow. Thank you. I really need to get used to using transformers. This example is a big help in showing how to use them practically. All the monad tutorials show you how to build one from scratch, but rarely do they show you how to leverage what's already available. – Steve Feb 12 '11 at 04:39
  • 1
    @Steve What helped me to understand monad transformers is to just think of them as a stack of monads or an onion with layers and the record fields or run functions of each monad transformer type pops/peels off a layer to reveal the level below. – snk_kid Feb 12 '11 at 08:54