Executes the interpreter. Returns Left InterpreterError in case of error.

NB. The underlying ghc will overwrite certain signal handlers (SIGINT, SIGHUP, SIGTERM, SIGQUIT on Posix systems, Ctrl-C handler on Windows). In future versions of hint, this might be controlled by the user.

Available options are:

• languageExtensions
• installedModulesInScope
• searchPath

Retrieves the value of an option.

Use this function to set or modify the value of any option. It is invoked like this:

set [opt1 := val1, opt2 := val2,... optk := valk]

Language extensions in use by the interpreter.

Default is: [] (i.e. none, pure Haskell 98)

List of the extensions known by the interpreter.

This represents language extensions beyond Haskell 98 that are supported by GHC (it was taken from Cabal's Language.Haskell.Extension)

When set to True, every module in every available package is implicitly imported qualified. This is very convenient for interactive evaluation, but can be a problem in sandboxed environments (e.g. unsafePerformIO is in scope).

Default value is True.

Observe that due to limitations in the GHC-API, when set to False, the private symbols in interpreted modules will not be in scope.

The search path for source files. Observe that every time it is set, it overrides the previous search path. The default is ["."].

Keep in mind that by a limitation in ghc, "." is always in scope.

Module names are _not_ filepaths.

Returns True if the module was interpreted.

Tries to load all the requested modules from their source file. Modules my be indicated by their ModuleName (e.g. "My.Module") or by the full path to its source file.

The interpreter is reset both before loading the modules and in the event of an error.

IMPORTANT: Like in a ghci session, this will also load (and interpret) any dependency that is not available via an installed package. Make sure that you are not loading any module that is also being used to compile your application. In particular, you need to avoid modules that define types that will later occur in an expression that you will want to interpret.

The problem in doing this is that those types will have two incompatible representations at runtime: 1) the one in the compiled code and 2) the one in the interpreted code. When interpreting such an expression (bringing it to program-code) you will likely get a segmentation fault, since the latter representation will be used where the program assumes the former.

The rule of thumb is: never make the interpreter run on the directory with the source code of your program! If you want your interpreted code to use some type that is defined in your program, then put the defining module on a library and make your program depend on that package.

Returns the list of modules loaded with loadModules.

Sets the modules whose context is used during evaluation. All bindings of these modules are in scope, not only those exported.

Modules must be interpreted to use this function.

Sets the modules whose exports must be in context.

Warning: setImports and setImportsQ are mutually exclusive. If you have a list of modules to be used qualified and another list unqualified, then you need to do something like

 setImportsQ ((zip unqualified $ repeat Nothing) ++ qualifieds)

Sets the modules whose exports must be in context; some of them may be qualified. E.g.:

setImportsQ [(Prelude, Nothing), (Data.Map, Just M)].

Here, "map" will refer to Prelude.map and "M.map" to Data.Map.map.

All imported modules are cleared from the context, and loaded modules are unloaded. It is similar to a :load in GHCi, but observe that not even the Prelude will be in context after a reset.

An Id for a class, a type constructor, a data constructor, a binding, etc

Gets an abstract representation of all the entities exported by the module. It is similar to the :browse command in GHCi.

Get the annotations associated with a particular module.

For example, given:

  RBRACE-# ANN module (1 :: Int) #-LBRACE
  module SomeModule(g, h) where
  ...
  

Then after using loadModule to load SomeModule into scope:

  x <- getModuleAnnotations (as :: Int) SomeModule
  liftIO $ print x
  -- result is [1]
  

Get the annotations associated with a particular function

For example, given:

  module SomeModule(g, h) where

  LBRACE-# ANN g (Just 1 :: Maybe Int) #-RBRACE
  g = f [f]

  LBRACE-# ANN h (Just 2 :: Maybe Int) #-RBRACE
  h = f
  

Then after using loadModule to bring SomeModule into scope:

  x <- liftM concat $ mapM (getValAnnotations (as :: Maybe Int)) ["g","h"]
  liftIO $ print x
  -- result is [Just 2, Just 1]
  

This can also work on data constructors and types with annotations.

Returns a string representation of the type of the expression.

Tests if the expression type checks.

Returns a string representation of the kind of the type expression.

Evaluates an expression, given a witness for its monomorphic type.

Convenience functions to be used with interpret to provide witnesses. Example:

• interpret "head [True,False]" (as :: Bool)

• interpret "head $ map show [True,False]" infer >>= flip interpret (as :: Bool)

Convenience functions to be used with interpret to provide witnesses. Example:

• interpret "head [True,False]" (as :: Bool)

• interpret "head $ map show [True,False]" infer >>= flip interpret (as :: Bool)

eval expr will evaluate show expr. It will succeed only if expr has type t and there is a Show instance for t.

The installed version of ghc is not thread-safe. This exception is thrown whenever you try to execute runInterpreter while another instance is already running.

Version of the underlying ghc api. Values are:

• 708 for GHC 7.8.x
• 710 for GHC 7.10.x
• etc...

Conceptually, parens s = "(" ++ s ++ ")", where s is any valid haskell expression. In practice, it is harder than this. Observe that if s ends with a trailing comment, then parens s would be a malformed expression. The straightforward solution for this is to put the closing parenthesis in a different line. However, now we are messing with the layout rules and we don't know where s is going to be used! Solution: parens s = "(let {foo =n" ++ s ++ "\n ;} in foo)" where foo does not occur in s