[Haskell-beginners] defining expression
Stephen Blackheath [to Haskell-Beginners]
mutilating.cauliflowers.stephen at blacksapphire.com
Sun Feb 7 15:43:26 EST 2010
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
More information about the Beginners
mailing list