observe $ flip runStateT 10 $ (put 0 mzero) | modify (+3)
((),13)
If the only thing you need is backtracking, using LogicT might be a little
overkill, using Maybe in the bottom of you monad stack suits just fine:
case flip runStateT 10 $ (put 0 mzero) | modify (+3) of
Just x -
* Yves Parès yves.pa...@gmail.com [2012-05-28 11:28:22+0200]
observe $ flip runStateT 10 $ (put 0 mzero) | modify (+3)
((),13)
If the only thing you need is backtracking, using LogicT might be a little
overkill, using Maybe in the bottom of you monad stack suits just fine:
case flip
Actually, I think the backtracking property here stems more from the
MonadPlus StateT instance than from the properties of Maybe.
(mplus a b runs a and b by passing explicitely the same state to them).
2012/5/28 Roman Cheplyaka r...@ro-che.info
* Yves Parès yves.pa...@gmail.com [2012-05-28
Hello cafe,
I'm working on a project where the main goal of the program is
building some complex output (e.g. a Haskell function, module, etc.).
In this process there is almost always some partially finished product
on which to work. Currently I'm modelling this with a wrapper around
StateT
It's common to use a writer monad possibly stacked with other monads
(e.g. a state monad for fresh variable names) for code generation that
approximates macro expansion - i.e. one call in Haskell maps to
one-or-more lines of code in the output language, no global
transformations are permitted.
If
On 5/27/12 8:21 AM, L Corbijn wrote:
2. My solution with saving/reverting monad-stacks seems quite a
hassle/hack, so is it a good approach or is there something better?
One good solution for backtracking is to use logict[1]. I've used it with
various state-like monads and it works well (e.g.,
* L Corbijn aspergesoe...@gmail.com [2012-05-27 14:21:39+0200]
The solution I've in mind depends on the stack being pure. When the
monad stack is pure a rule can be applied, returning a maybe value (or
having a MaybeT wrapper) and when returning Nothing (failed rule)
reverting the stack to
