Statement evaluator trace in Haskell

Question

I'm attempting writing a program which takes in any generic statement, evaluates it, and shows each step as it is evaluated.

For example, if we have a sequence of assignment statements, it should run as:

Evaluate Assignment Statement 1
Show Evaluation Result 1
Evaluate Assignment Statement 2
Show Evaluation Result 2

Right now, it shows only the final result. The code is

> evalS_maybe :: Statement -> Store -> Maybe Store

> evalS_maybe w@(While e s1) s   = evalS_maybe (If e 
>                                                   (Sequence s1 (While e s1)) 
>                                                       Skip) 
>                                               s 
> evalS_maybe Skip s             = Just s
> evalS_maybe (Sequence s1 s2) s = do
>                                   sq <-evalS_maybe s1 s
>                                   evalS_maybe s2 sq
> evalS_maybe (Assign x e ) s    = do 
>                                   ag <-evalE_maybe e s
>                                   return ( Map.insert x ag s )
> evalS_maybe (If e s1 s2) s     = do
>                                       b2 <- evalE_maybe e s 
>                                       case b2 of 
>                                           BoolVal True    ->  evalS_maybe s1 s
>                                           BoolVal False   ->  evalS_maybe s2 s
>                                           _               ->  return s

Edit:

The rest of the data types used are:

> type Variable = String

> data Statement =
>     Assign Variable Expression         
>   | If Expression Statement Statement   
>   | While Expression Statement          
>   | Sequence Statement Statement       
>   | Skip                                
>   deriving (Show)


> data Expression =
>     Var Variable                        
>   | Val Value                          
>   | Op  Bop Expression Expression
>   deriving (Show)


> data Bop =
>     Plus    
>   | Minus   
>   | Times   
>   | Divide  
>   | Gt      
>   | Ge      
>   | Lt      
>   | Le      
>   deriving (Show)

> data Value =
>     IntVal Int
>   | BoolVal Bool
>   deriving (Show)

>   type Store = Map Variable Value

Can anybody please help? Thanks in advance!

You'll need to show us the data definitions for `Statement` and `Store` before we can give you any useful help. — Chris Taylor, Feb 06 '13 at 08:36
@ChrisTaylor, I have tried adding the same by editing the question. Can you please help? Thanks. — Dev Dreamer, Feb 06 '13 at 09:36
What is the specific problem that you're facing? Why aren't you able to do this? Right now, the question sounds like "There's something my program doesn't do. Can you finish it for me?" That's not a good question for StackOverflow. Can you be more specific? What have you tried? — Matt Fenwick, Feb 06 '13 at 11:55
I've answered the basically the same question [here](http://stackoverflow.com/questions/13794556); it shouldn't be hard to adapt to your needs. — Fixnum, Feb 06 '13 at 19:03

score 1 · Answer 1 · answered Feb 06 '13 at 15:18

If you only want to see the traces, you can just use trace from Debug.Trace to "cheat" referential transparency and output intermediate information.

The other approach is to wrap a WriterT around your Maybe, and use tell to emit intermediate information. This actually will give back some values you can inspect in Haskell.

Note that this gives back your trace only if your evaluation succeeds. To always give back a trace, you wrap MaybeT over Writer instead.

Statement evaluator trace in Haskell

1 Answers1