On 6 Feb 2008, at 7:30 PM, Uwe Hollerbach wrote:

Hi, all, thanks for the responses. I understand the distinction between pure functions and impure functions/procedures/IO actions,

Um, I'm not sure of that, given what you go on to say.

it just felt to me in the samples that I quoted that I was in fact starting from basically the starting point,

Not really. The key difference to understand is that between difference between getCurrentTime and toUTCTime 42. These are your `starting points' --- the rest is just pure code.

eventually getting to the same endpoint (or at least a pair of endpoints that are not easily distinguished from each other by looking just at code), and inbetween

Well, the in-between paths are pure (or can be) either way. It's the starting point that needs liftIO or not.

one path was going through liftIO and the other not. But I guess it comes down to the fact that, since I'm in a REPL, I'm wallowing in impurity all the time (or something like that :-) )

jcc

All right, after a bit of dinner and some time to mess about, here's another attempt to check my understanding: here is a simplified version of the lisp-time example:

module Main where import System.Time

pure_fn :: Integer -> String pure_fn n = calendarTimeToString (toUTCTime (TOD n 0))

wicked_fn :: IO String wicked_fn = getClockTime >>= return . pure_fn . toI where toI (TOD n _) = n

make_wicked :: String -> IO String make_wicked str = return str

-- use of pure_fn -- main = putStrLn (pure_fn 1230000000)

-- use of wicked_fn -- main = wicked_fn >>= putStrLn

-- use of make_wicked main = (make_wicked (pure_fn 1234567890)) >>= putStrLn

If I use the first of the three "main" alternatives, I'm calling a pure function directly: it takes an integer, 123..., and produces a string. If I pass the same integer to the pure function, I'll get the same value, every time. This string is passed to putStrLn, an IO action, in order that I may gaze upon it, but the string itself is not thereby stuck in the IO monad. If I use the second of the three "main" alternatives, I'm calling an IO action: wicked_fn, which returns the current time formatted as UTC. In principle, every time I call wicked_fn, I could get a different answer. Because it's an IO action, I can't just pass it to putStrLn in the same way I passed in the previous pure_fn value, but instead I have to use the bind operator >>=. If I use the third of the "main" alternatives, I am starting with a pure function: it's that number formatted as UTC (it happens to come to Fri Feb 13 of next year), but then I pass it through the make_wicked function, which transmogrifies it into the IO monad. Therefore, as in the above, I have to use >>= in order to get it to work; "putStrLn (make_wicked (pure_fn 123...))" doesn't work. <deep breath> OK, after all that, my original question, in terms of this example: "the IO monad is one-way" is equivalent to saying there is no haskell function that I could write that would take

(make_wicked (pure_fn 123456))

and make it into something that could be used in the same way and the same places as just plain

(pure_fn 123456)

? And, coming back to my scheme interpreter, this is at least somewhat irrelevant, because, since I am in a REPL of my own devising, I'm firmly in IO-monad-land, now and forever. Right? thanks, Uwe

On 6 Feb 2008, at 11:32 PM, Uwe Hollerbach wrote:

All right, after a bit of dinner and some time to mess about, here's another attempt to check my understanding: here is a simplified version of the lisp-time example:

...

module Main where import System.Time

pure_fn :: Integer -> String pure_fn n = calendarTimeToString (toUTCTime (TOD n 0))

wicked_fn :: IO String wicked_fn = getClockTime >>= return . pure_fn . toI where toI (TOD n _) = n

make_wicked :: String -> IO String make_wicked str = return str

-- use of pure_fn -- main = putStrLn (pure_fn 1230000000)

-- use of wicked_fn -- main = wicked_fn >>= putStrLn

-- use of make_wicked main = (make_wicked (pure_fn 1234567890)) >>= putStrLn

If I use the first of the three "main" alternatives, I'm calling a pure function directly: it takes an integer, 123..., and produces a string. If I pass the same integer to the pure function, I'll get the same value, every time. This string is passed to putStrLn, an IO action, in order that I may gaze upon it, but the string itself is not thereby stuck in the IO monad.

If I use the second of the three "main" alternatives, I'm calling an IO action: wicked_fn, which returns the current time formatted as UTC. In principle, every time I call wicked_fn, I could get a different answer. Because it's an IO action, I can't just pass it to putStrLn in the same way I passed in the previous pure_fn value, but instead I have to use the bind operator >>=.

If I use the third of the "main" alternatives, I am starting with a pure function: it's that number formatted as UTC (it happens to come to Fri Feb 13 of next year), but then I pass it through the make_wicked function, which transmogrifies it into the IO monad. Therefore, as in the above, I have to use >>= in order to get it to work; "putStrLn (make_wicked (pure_fn 123...))" doesn't work.

<deep breath>

OK, after all that, my original question, in terms of this example: "the IO monad is one-way" is equivalent to saying there is no haskell function that I could write that would take

...

(make_wicked (pure_fn 123456))

and make it into something that could be used in the same way and the same places as just plain

...

(pure_fn 123456)

?

And, coming back to my scheme interpreter, this is at least somewhat irrelevant, because, since I am in a REPL of my own devising, I'm firmly in IO-monad-land, now and forever.

Right. jcc

Thanks, I'm going to have to study this a bit... Uwe On 2/7/08, Ryan Ingram wrote:

On 2/6/08, Uwe Hollerbach wrote:

...

And, coming back to my scheme interpreter, this is at least somewhat irrelevant, because, since I am in a REPL of my own devising, I'm firmly in IO-monad-land, now and forever.

This is not entirely true; a REPL can be pure.

Consider the following simple stack-based-calculator; all the IO happens within "interact", the REPL itself is pure:

import System.IO

main = hSetBuffering stdout NoBuffering >> interact replMain

replMain s = "Stack calculator\n> " ++ repl [] s

repl :: [Int] -> String -> String repl _ [] = "" repl _ ('q':_) = "" repl s ('\n':xs) = show s ++ "\n> " ++ repl s xs repl s xs@(x:_) | x >= '0' && x <= '9' = let (v, xs') = head $ reads xs in repl (v:s) xs' repl s (c:xs) | c `elem` validCommands = case command c s of Just s' -> repl s' xs Nothing -> "<stack underflow>\n" ++ repl s xs repl s (_:xs) = repl s xs -- ignore unrecognized characters

validCommands = ".d+c" command :: Char -> [Int] -> Maybe [Int] command '.' (x:xs) = Just xs command 'd' (x:xs) = Just $ x:x:xs command '+' (x:y:xs) = Just $ (x+y):xs command 'c' _ = Just [] command _ _ = Nothing

You can go further than "interact" if you want to abstract away the impurity in your system and take input from some outside process which has a limited set of impure operations. Take a look here for an example using "Prompt" (which has seen some discussion here on haskell-cafe): http://paste.lisp.org/display/53766

In that example, "guess n" is an action in the pure Prompt monad; different interpretation functions allow this monad to interact with an AI (in a semi-pure setting; it outputs strings), or with a real player via the full IO interface. A similar mechanism could be used for the scheme REPL to make it as "pure" as possible, with "getClockTime" being replaced by "prompt GetClockTime" to interact with the outside world.