hint
Runtime Haskell interpreter (GHC API wrapper)
https://github.com/haskell-hint/hint
| Version on this page: | 0.9.0.5 |
| LTS Haskell 22.39: | 0.9.0.8 |
| Stackage Nightly 2024-10-31: | 0.9.0.8 |
| Latest on Hackage: | 0.9.0.8 |
hint-0.9.0.5@sha256:c835e2d0dcf35c00d71fc7dff64da74ddec40917f6b6afdeb9de66d3c826a1eb,3249Module documentation for 0.9.0.5
- Hint
- Language
hint 
This library defines an Interpreter monad within which you can interpret
strings like "[1,2] ++ [3]" into values like [1,2,3]. You can easily
exchange data between your compiled program and your interpreted program, as
long as the data has a Typeable instance.
You can choose which modules should be in scope while evaluating these expressions, you can browse the contents of those modules, and you can ask for the type of the identifiers you’re browsing.
It is, essentially, a huge subset of the GHC API wrapped in a simpler API.
Limitations
It is possible to run the interpreter inside a thread, but on GHC 8.8 and below, you can’t run two instances of the interpreter simultaneously.
GHC must be installed on the system on which the compiled executable is running.
Example
{-# LANGUAGE LambdaCase, ScopedTypeVariables, TypeApplications #-}
import Control.Exception (throwIO)
import Control.Monad (when)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Writer (execWriterT, tell)
import Data.Foldable (for_)
import Data.List (isPrefixOf)
import Data.Typeable (Typeable)
import qualified Language.Haskell.Interpreter as Hint
-- |
-- Interpret expressions into values:
--
-- >>> eval @[Int] "[1,2] ++ [3]"
-- Right [1,2,3]
--
-- Send values from your compiled program to your interpreted program by
-- interpreting a function:
--
-- >>> Right f <- eval @(Int -> [Int]) "\\x -> [1..x]"
-- >>> f 5
-- [1,2,3,4,5]
eval :: forall t. Typeable t
=> String -> IO (Either Hint.InterpreterError t)
eval s = Hint.runInterpreter $ do
Hint.setImports ["Prelude"]
Hint.interpret s (Hint.as :: t)
-- |
-- >>> :{
-- do Right contents <- browse "Prelude"
-- for_ contents $ \(identifier, tp) -> do
-- when ("put" `isPrefixOf` identifier) $ do
-- putStrLn $ identifier ++ " :: " ++ tp
-- :}
-- putChar :: Char -> IO ()
-- putStr :: String -> IO ()
-- putStrLn :: String -> IO ()
browse :: Hint.ModuleName -> IO (Either Hint.InterpreterError [(String, String)])
browse moduleName = Hint.runInterpreter $ do
Hint.setImports ["Prelude", "Data.Typeable", moduleName]
exports <- Hint.getModuleExports moduleName
execWriterT $ do
for_ exports $ \case
Hint.Fun identifier -> do
tp <- lift $ Hint.typeOf identifier
tell [(identifier, tp)]
_ -> pure () -- skip datatypes and typeclasses
Check example.hs for a longer example (it must be run from hint’s base directory).