Haskell的副作用和I / O

Question

Ok so I'm a newbie to Haskell IO. I've read a lot about IO and side effects in Haskell functions, and now I have come to do some side effects of my own in Haskell and I'm wondering - how do I actually write this stuff?

I have the following function, whereupon after running one of the lines of code, I want to do some printing, which is explained by the comments in the first couple of lines.

I'm pretty sure I need to change the function's type signature, maybe I'll need to use Maybe. Maybe it's not even possible to do this way and I have to completely rewrite it? I don't really know - but I'm looking for guidance. How do I go about including this functionality?

interpret_statement :: Prog -> Vars -> Stmt -> Vars -- one third of the debug -d functionality goes here 
                                                    -- AFTER every assignment is executed, the interpreter should print a line specifying
                                                    -- the variable being assigned to AND its new value
interpret_statement prog vars@(Vars _ b c d) (Assign A expr) = Vars (interpret_expr prog vars expr) b c d
interpret_statement prog vars@(Vars a _ c d) (Assign B expr) = Vars a (interpret_expr prog vars expr) c d
interpret_statement prog vars@(Vars a b _ d) (Assign C expr) = Vars a b (interpret_expr prog vars expr) d
interpret_statement prog vars@(Vars a b c _) (Assign D expr) = Vars a b c (interpret_expr prog vars expr)

Answer 1

I'm going to start with the code from Adrian's answer.

interpret_statement :: Prog -> Vars -> Stmt -> IO Vars
interpret_statement prog vars@(Vars _ b c d) (Assign A expr) = do
    print "some debug"
    return $ Vars (interpret_expr prog vars expr) b c d
-- etc

This is correct as far as it goes, but there are some issues:

• the debugging output is compulsory, but presumably you want it to be optional
• although we need the result type to be IO Vars in order to perform i/o, this makes it harder to test interpret_statement

A solution:

• add a function parameter to interpret_statement that performs any required i/o
• make that function polymorphic so that its result type determines the result type of interpret_statement

eg (and forgive me for guessing at your types: I assume data VarName = A | B | C | D and data Vars = Vars Value Value Value Value ):

interpret_statement :: (VarName -> Value -> Vars -> o) ->
                       Prog -> Vars -> Stmt -> o
interpret_statement debug prog vars@(Vars _ b c d) (Assign A expr)
    = debug A newValue $ Vars (interpret_expr prog vars expr) b c d
-- etc

Useful functions you can provide as that parameter are:

purePassthrough :: VarName -> Value -> Vars -> Vars
purePassthrough _ _ vars = vars

• use when you are testing interpret_statement from QuickCheck and would like it to be pure
• interpret_statement purePassthrough :: Prog -> Vars -> Stmt -> Vars , as in your original interpret_statement

writeDebuggingInfo :: VarName -> Value -> Vars -> IO Vars
writeDebuggingInfo varName newValue newVars = do
    putStrLn $ show varName ++ " := " ++ show newValue
        -- or whatever debugging output you want
    return newVars

• use in your program when you require debugging information to be written
• interpret_statement writeDebuggingInfo :: Prog -> Vars -> Stmt -> IO Vars , as in Adrian's answer

dontWriteDebuggingInfo :: VarName -> Value -> Vars -> IO Vars
dontWriteDebuggingInfo :: _ _ newVars = return newVars

• interpret_statement dontWriteDebuggingInfo :: Prog -> Vars -> Stmt -> IO Vars , as in the previous case

• use when you may or may not want debugging output, eg

   newVars <- interpret_statement (if wantDebuggingOutput then writeDebuggingInfo else dontWriteDebuggingInfo) program vars statement 

Answer 2

You are correct. If you want to do some printing your code must live in some monad. Monad responsible for handling operations on real world - like printing on screen - is IO monad. So to use functions like putStrLn, print, getLine you need to change function signature to:

interpret_statement :: Prog -> Vars -> Stmt -> IO Vars

And use do notation. Result of the function must be then wrapped by return funciton, but I am sure you already know this about monads.

For example:

interpret_statement prog vars@(Vars _ b c d) (Assign A expr) = do
    print "some debug"
    return $ Vars (interpret_expr prog vars expr) b c d