[Haskell-beginners] defining expression

[Stephen Blackheath [to Haskell-Beginners]]

John,

I'm seeing the error you describe "Couldn't match expected type `Expression'
            against inferred type `IO b'" on this line:

evalStep d (Let n e1 e2) = do
        putStrLn ("Adding definition for "++n)     <---

The trouble here is that evalStep's type is :: Dict -> Expression -> 
Expression, and Haskell doesn't allow general I/O in a function with a 
return type other than IO <something>.  This restrictiveness is pretty 
much the whole point of Haskell.  You have two choices, either...

1. Change the type of evalStep to Dict -> Expression -> IO Expression, 
and of any function that calls it (and so on up the call chain), or

2. Use Debug.trace for your debug output, like this:

     trace ("adding/removing definition of "++n) $
     evalStep d (addEntry n e1 d) e2

If you want 'adding' and 'removing definition of' as separate messages 
before and after (sequenced relative to other traces you might add), 
this is not straightforward, but it can be done.  Essentially in pure 
Haskell code you have to think in terms of data dependency rather than 
sequence in time.


Steve

John Moore wrote:
> Hi,
>    This gives me the explaination that it expecting a Expression but it 
> been giving a IO b can some explain whats going on please.
>  
> import Maybe
> data Expression = Val Double
>                | Add Expression Expression
>                | Subtract Expression Expression
>                | Multiply Expression Expression
>                | Divide Expression Expression
>         | Var String
>         | Let String Expression Expression
>         deriving Show
> demo1 = (Add(Multiply(Divide(Subtract(Val 25)(Val 5))(Val 10))(Val 
> 7))(Val 30))
> type Dict =[(String,Expression)]
> emptyDict :: Dict
> emptyDict = []
> addEntry :: String->Expression ->Dict -> Dict
> addEntry n e d = (n,e): d
> lookupEntry :: String -> Dict -> Maybe Expression
> lookupEntry n [] = Nothing
> lookupEntry n (x:xs) = if (n == k)
>    then (Just v)
>                 else lookupEntry n xs
>    where (k,v) = x
> evalStep :: Dict -> Expression ->  Expression
> evalStep d(Val x)=  (Val x)
> 
> evalStep d(Add x y)
>   = case x of
>       (Val a) -> case y of
>                    (Val b) -> Val (a+b)
>                    left -> Add x (evalStep d y)
>       right -> Add (evalStep d x)y
> evalStep d(Subtract x y)
>   = case x of
>       (Val a) -> case y of
>                    (Val b) -> Val (a-b)
>                    left -> Subtract x (evalStep d y)
>       right -> Subtract (evalStep d x)y
> evalStep d(Multiply x y)
>   = case x of
>       (Val a) -> case y of
>                    (Val b) -> Val (a*b)
>                    left -> Multiply x (evalStep d y)
>       right -> Multiply (evalStep d x)y
> evalStep d (Divide x y)
>   = case x of
>       (Val a) -> case y of
>                    (Val b) -> Val (a/b)
>                    left -> Divide x (evalStep d y)
>       right -> Divide (evalStep d x)y
> evalStep d (Let n e1 e2) = do
>        putStrLn ("Adding definition for "++n)
>        v <- evalStep d (addEntry n e1 d) e2
>        putStrLn ("Removing definition for "++n)
>        return v
> 
> evaluate :: Dict-> [Expression] -> Expression -> IO ()
> evaluate d(x:xs) e = do
>      putStrLn (show e)
>      putStrLn "Do another step (y/n) or rollback (r)? :"
>      c <- getLine
>      case c of
>        "y" -> let e'= (evalStep d e)in evaluate d (e:x:xs) e'-- build up 
> history
>                 
>        "r" ->  case (x:xs) of
>   (x:xs)-> evaluate d xs x
>   []-> do { putStrLn "Empty"
>    ;evaluate d(x:xs) e
>   }
>        "n"  ->  putStrLn $ "Ok you said no :" ++ c
>                                           
>                 
> John
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners