2009/3/13 Marcin Kosiba :

On Friday 13 March 2009, you wrote:

...

2009/3/13 Marcin Kosiba :

...

On Thursday 12 March 2009, you wrote:

...

2009/3/12 Marcin Kosiba :

...

Hi, I'm doing a bit of research into mobility models and I'm currently exploring implementation language choices for the simulator (*snip*) The simulation algorithm requires expressing the node's mobility so that it is "stateless". The mobility model algorithm's type should be something like: mobility_model :: WorldState -> NodeState -> OtherInput -> (Action, NodeState)

where Action can alter WorldState and the second NodeState is an altered input NodeState. I perform a form of speculative execution on mobility_model so sometimes I need to backtrack to a previous world and node state. This is all fairly simple stuff, and was just an introduction. What I do now is store an enum in NodeState and implement mobility_model as one big case statement. Yes, this is very imperative of me, I know. What I'd like to do is to express mobility_model, so that the code would look like:

mobility_model world node input = do do_calculus emit_action if something then emit_action else emit_action do_calculus emit_action mobility_model world node input

Hi,

It seems you can use http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/Control- Mon ad-State-Lazy.html Just have a look at the exemple :

tick :: State Int Int tick = do n <- get put (n+1) return n

your code would become something like mobility_model :: OtherInput -> State (WorldState,NodeState) () mobility_model input = do world <- gets fst node <- gets snd .... let (world',node') = ... put (world',node')

ok, that solves part of the problem. what this doesn't solve is that somewhere between these lines (which corespond to emit_action in my example)

...

let (world',node') = ... put (world',node')

I need to return a value and an Action and NodeState to the simulation algorithm. and then, after the simulation algorithm calculates a new WorldState it will want the mobility_model to where it left off, but with a new WorldState.

I hope I'm clear about what I wish to achieve: each emit_action should return a value (Action, NodeState) and maybe a function mobility_model_cont which I then could call with the new WorldState to continue from where emit_action returned.

I'm not entirely sure ... but I think it doesn't matter that much :) Here is why.

This was just an exemple : mobility_model :: OtherInput -> State (WorldState,NodeState) ()

You could also have mobility_model :: OtherInput -> NodeState -> State WorldState (NodeState,Action) or whatever.

In fact, the State monad makes it easy to thread (in this context, it means 'pass around') an argument to many functions, providing a nice syntax reminiscent of imperative language. But it lets you completely free of what is passed around. It depends on what you want to be explicitely passed by argument, and what you want to pass in the state of the monad (that is, what you want to appear, inside the monad only, as some global variable).

So in your code, if you often need to pass a WorldState to a function which should return a modified WorldState, it makes sense to put WorldState inside the state monad. But, maybe, if there is just a few functions which act on NodeState, it has not to be part of the state carried by the state monad.

I'm not entirely sure of what is a problem to you : is it the use of the State monad, or something else ? If it can help you to formulate your question you can post some code (or past it to http://hpaste.org/)...

Threading the state is not the problem. Maybe this will help: what I have now:

fsm world state = case state of first -> do_stuff_one (move_up, succ state) second -> do_stuff_two (move_left, succ state) third -> do_stuff_three (move_right, first)

what I'd want to have is to say: fsm world state = do do_stuff_one yield move_up do_stuff_two yield move_left do_stuff_three yield move_right fsm world state

and have it "translated" to:

fsm world state = do_stuff_one (move_up, \world' state' -> do_stuff_two (move_left, \world'' state'' -> do_stuff_three (move_right, fsm world'' state'')

Sorry, I never used continuations or coroutines in Haskell. But, if your goal is to be less imperative, I'm not sure using 'yield' is what you want. If what you do is well expressed by a fsm, maybe you should stick to it. Thu