How to evaluate an IO function?

[yaitskov]

Hi,

eval function expects pure value, but how to call function :: Show a => IO a?

Trick with unsafePerformIO at first glance is working as expected,
but I am not sure if it is best solution.

[gelisam]

There are a few other solutions.

First, since IO actions are ordinary values, you can use interpret to obtain a value of type IO (), and then run that IO action outside of the interpreter:

import Control.Exception (throwIO)
import Control.Monad.IO.Class (liftIO)
import qualified Language.Haskell.Interpreter as Hint

-- |
-- Execute an expression of type IO ()
--
-- >>> interpretIO "mapM_ print [1,2,3]"
-- 1
-- 2
-- 3
interpretIO :: String -> IO ()
interpretIO expr = do
  r <- Hint.runInterpreter $ do
    Hint.setImports ["Prelude"]
    ioAction <- Hint.interpret expr (Hint.as :: IO ())
    liftIO ioAction
  case r of
    Left e -> do
      throwIO e
    Right () -> do
      pure ()

You can do the same with a value of type IO String:

-- |
-- Execute an expression of type (IO String), and return the String.
--
-- >>> interpretIOString "mapM (\\x -> print x >> pure (chr x)) [65,66,67]"
-- 65
-- 66
-- 67
-- "ABC"
interpretIOString :: String -> IO String
interpretIOString expr = do
  r <- Hint.runInterpreter $ do
    Hint.setImports ["Prelude", "Data.Char"]
    ioAction <- Hint.interpret expr (Hint.as :: IO String)
    liftIO ioAction
  case r of
    Left e -> do
      throwIO e
    Right s -> do
      pure s

And if you want to support an arbitrary a which has a Show instance, you just need to throw in a call to show inside the interpreter:

-- |
-- Execute an expression of type (IO a), for some type "a" which has a Show
-- instance, and return the shown result.
--
-- >>> interpretIOShow "mapM print [1,2,3]"
-- 1
-- 2
-- 3
-- "[(),(),()]"
interpretIOShow :: String -> IO String
interpretIOShow expr = do
  interpretIOString ("fmap show $ " ++ expr)

Finally, if you don't need to get the String back, and only want to print it like in ghci, you can use runStmt:

-- |
-- Like 'interpretIOShow', but print the result instead of returning it.
--
-- >>> runIOShow "mapM print [1,2,3]"
-- 1
-- 2
-- 3
-- [(),(),()]
runIOShow :: String -> IO ()
runIOShow expr = do
  r <- Hint.runInterpreter $ do
    Hint.setImports ["Prelude"]
    Hint.runStmt expr
  case r of
    Left e -> do
      throwIO e
    Right () -> do
      pure ()

[gelisam]

I have now enabled GitHub's "Discussions" feature on this repo, to indicate that questions like this one are welcome even though they're not bugs.