How to turn IO Actions into a "pure" function

Question

Haskell newbie here. I have a higher order function myTransform at hand, which takes a function fn :: String -> String and do some fancy things. Let's assume the implementation is

myTransform :: Int -> (String -> String) -> String -> [String]
myTransform n f = take n . iterate f

now I want to transform an external program, which is, if I understand right, an IO action. Preferably, the signature should be String -> IO String:

import System.Process
externProg :: String -> IO String
externProg s = readProcess "echo" ["-n", s, "+ 1"] ""

the question is, is there any way I can fit this String -> IO String function into that String -> String argument slot, without changing, or even knowing, how myTransform implements?

Answer 1

No, you can not. You will have to make a monadic version of myTransform. It is custom to append a capital M. I.e. map becomes mapM. fold becomse foldM ... Unfortunately there is no iterateM. I would therefore skip iterateM and implement it directly.

myTransformM' :: (Monad m) => Int -> (String -> m String) -> String -> m [String]
myTransformM' 0 f str = return [str]
myTransformM' n f str = do
    results <- myTransformM (n-1) f str
    next <- f (head results)
    return (next:results)

myTransformM n f str = do
    results <- myTransformM' n f str
    return $ reverse results

You might notice that the results of the first function are ordered the other way around. This is in order to avoid the function being quadratic.

You can try yourself what will happen if you implement iterateM. It will just loop eternally. This is because Haskell can never know if you will actually get a list back or if there will be an IOError somewhere down the road. Similarly if you take the Maybe monad, Haskell will never know if you actually get a Just list back or if down the road somewhere there is a Nothing.

iterateM :: (Monad m) => (a -> m a) -> a -> m [a]
iterateM f a = do
    result <- f a
    results <- iterateM f result
    return (result:results)

Answer 2

This is a common dup, but I have a moment so...

No, you should run the IO action and thus obtain the String typed value which is passed to your myTransform.

For example:

main :: IO ()
main =
  do stdout <- externProg "myProg"  -- "execute" the IO action and obtain "stdout :: String"
     let res = myTransform stdout  -- res :: String
     putStrLn res

Or once you're comfortable in the language and if you are ok with the style:

main :: IO ()
main = putStrLn . myTransform =<< externProg "myProg"

Answer 3

The answer by yokto explains the issue very well. I'll only add a further example.

Consider this function:

f1 :: (Int -> Int) -> Int
f1 g = g 10 + g 20

f2 :: (Int -> Int) -> Int
f2 g = g 20 + g 10

These functions have exactly the same semantics. A Haskell implementation can rewrite the first into the second one, it it wishes, without affecting the outcome.

Now, consider

myG :: Int -> IO Int
myG x = print x >> return x

main :: IO ()
main = do
   x <- f1 myG  -- assume this could be made to work, somehow
   print x

What should this print? Intuitively, it prints either

10
20
30

or

20
10
30

depending on the evaluation order used in f1. This is bad since f2 could also have been used, and it should lead to the same result, but likely will lead to the other. Worse, the compiler could optimize one into the other, so any specific output is not really guaranteed: the compiler could change it at a whim.

This is a big problem, which Haskell was designed to avoid. The order of IO effects has to be completely specified in the program. For that, the programmer must be prevented to turn IO stuff (like Int -> IO Int) into non-IO stuff (like Int -> Int).

If we used a monadic type for f as in

f3 :: (Int -> IO Int) -> IO Int
f3 g = ...

then Haskell would force us to specify an order between g 10 and g 20.