{- |
Module      : Language.Egison.Eval
Licence     : MIT

This module provides interface for evaluating Egison expressions.
-}

module Language.Egison.Eval
  (
  -- * Eval Egison expressions
    evalExpr
  , evalTopExpr
  , evalTopExprStr
  , evalTopExprs
  , evalTopExprsNoPrint
  , runExpr
  , runTopExpr
  , runTopExprStr
  , runTopExprs
  -- * Load Egison files
  , loadEgisonLibrary
  , loadEgisonFile
  ) where

import           Control.Monad              (forM_, when)
import           Control.Monad.Except       (throwError)
import           Control.Monad.Reader       (ask, asks)
import           Control.Monad.State

import           Language.Egison.AST
import           Language.Egison.CmdOptions
import           Language.Egison.Core
import           Language.Egison.Data
import           Language.Egison.Desugar
import           Language.Egison.EvalState  (MonadEval (..))
import           Language.Egison.IExpr
import           Language.Egison.MathOutput (prettyMath)
import           Language.Egison.Parser


-- | Evaluate an Egison expression.
evalExpr :: Env -> Expr -> EvalM EgisonValue
evalExpr :: Env -> Expr -> EvalM EgisonValue
evalExpr Env
env Expr
expr = Expr -> EvalM IExpr
desugarExpr Expr
expr EvalM IExpr -> (IExpr -> EvalM EgisonValue) -> EvalM EgisonValue
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Env -> IExpr -> EvalM EgisonValue
evalExprDeep Env
env

-- | Evaluate an Egison top expression.
evalTopExpr :: Env -> TopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr :: Env -> TopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr Env
env TopExpr
topExpr = do
  Maybe ITopExpr
topExpr <- TopExpr -> EvalM (Maybe ITopExpr)
desugarTopExpr TopExpr
topExpr
  case Maybe ITopExpr
topExpr of
    Maybe ITopExpr
Nothing      -> (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe EgisonValue
forall a. Maybe a
Nothing, Env
env)
    Just ITopExpr
topExpr -> Env -> ITopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr' Env
env ITopExpr
topExpr

-- | Evaluate an Egison top expression.
evalTopExprStr :: Env -> TopExpr -> EvalM (Maybe String, Env)
evalTopExprStr :: Env -> TopExpr -> EvalM (Maybe String, Env)
evalTopExprStr Env
env TopExpr
topExpr = do
  (Maybe EgisonValue
val, Env
env') <- Env -> TopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr Env
env TopExpr
topExpr
  case Maybe EgisonValue
val of
    Maybe EgisonValue
Nothing  -> (Maybe String, Env) -> EvalM (Maybe String, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe String
forall a. Maybe a
Nothing, Env
env')
    Just EgisonValue
val -> do String
str <- EgisonValue -> EvalM String
valueToStr EgisonValue
val
                   (Maybe String, Env) -> EvalM (Maybe String, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Maybe String
forall a. a -> Maybe a
Just String
str, Env
env')

valueToStr :: EgisonValue -> EvalM String
valueToStr :: EgisonValue -> EvalM String
valueToStr EgisonValue
val = do
  Maybe String
mathExpr <- (EgisonOpts -> Maybe String)
-> StateT EvalState (ExceptT EgisonError RuntimeM) (Maybe String)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks EgisonOpts -> Maybe String
optMathExpr
  case Maybe String
mathExpr of
    Maybe String
Nothing   -> String -> EvalM String
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (EgisonValue -> String
forall a. Show a => a -> String
show EgisonValue
val)
    Just String
lang -> String -> EvalM String
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> EgisonValue -> String
prettyMath String
lang EgisonValue
val)

-- | Evaluate Egison top expressions.
evalTopExprs :: Env -> [TopExpr] -> EvalM Env
evalTopExprs :: Env -> [TopExpr] -> EvalM Env
evalTopExprs Env
env [TopExpr]
exprs = do
  [ITopExpr]
exprs <- [TopExpr] -> EvalM [ITopExpr]
desugarTopExprs [TopExpr]
exprs
  EgisonOpts
opts <- StateT EvalState (ExceptT EgisonError RuntimeM) EgisonOpts
forall r (m :: * -> *). MonadReader r m => m r
ask
  ([(Var, IExpr)]
bindings, [ITopExpr]
rest) <- EgisonOpts -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs EgisonOpts
opts [ITopExpr]
exprs
  Env
env <- Env -> [(Var, IExpr)] -> EvalM Env
recursiveBind Env
env [(Var, IExpr)]
bindings
  [ITopExpr]
-> (ITopExpr -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [ITopExpr]
rest ((ITopExpr -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
 -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> (ITopExpr -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b. (a -> b) -> a -> b
$ \ITopExpr
expr -> do
    (Maybe EgisonValue
val, Env
_) <- Env -> ITopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr' Env
env ITopExpr
expr
    case Maybe EgisonValue
val of
      Maybe EgisonValue
Nothing  -> () -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      Just EgisonValue
val -> EgisonValue -> EvalM String
valueToStr EgisonValue
val EvalM String
-> (String -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= IO () -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a. IO a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> (String -> IO ())
-> String
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ()
putStrLn
  Env -> EvalM Env
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Env
env

-- | Evaluate Egison top expressions.
evalTopExprsNoPrint :: Env -> [TopExpr] -> EvalM Env
evalTopExprsNoPrint :: Env -> [TopExpr] -> EvalM Env
evalTopExprsNoPrint Env
env [TopExpr]
exprs = do
  [ITopExpr]
exprs <- [TopExpr] -> EvalM [ITopExpr]
desugarTopExprs [TopExpr]
exprs
  EgisonOpts
opts <- StateT EvalState (ExceptT EgisonError RuntimeM) EgisonOpts
forall r (m :: * -> *). MonadReader r m => m r
ask
  ([(Var, IExpr)]
bindings, [ITopExpr]
rest) <- EgisonOpts -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs EgisonOpts
opts [ITopExpr]
exprs
  Env
env <- Env -> [(Var, IExpr)] -> EvalM Env
recursiveBind Env
env [(Var, IExpr)]
bindings
  [ITopExpr]
-> (ITopExpr -> EvalM (Maybe EgisonValue, Env))
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [ITopExpr]
rest ((ITopExpr -> EvalM (Maybe EgisonValue, Env))
 -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> (ITopExpr -> EvalM (Maybe EgisonValue, Env))
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b. (a -> b) -> a -> b
$ Env -> ITopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr' Env
env
  Env -> EvalM Env
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Env
env

-- | Evaluate an Egison expression. Input is a Haskell string.
runExpr :: Env -> String -> EvalM EgisonValue
runExpr :: Env -> String -> EvalM EgisonValue
runExpr Env
env String
input =
  String -> EvalM Expr
readExpr String
input EvalM Expr -> (Expr -> EvalM EgisonValue) -> EvalM EgisonValue
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Env -> Expr -> EvalM EgisonValue
evalExpr Env
env

-- | Evaluate an Egison top expression. Input is a Haskell string.
runTopExpr :: Env -> String -> EvalM (Maybe EgisonValue, Env)
runTopExpr :: Env -> String -> EvalM (Maybe EgisonValue, Env)
runTopExpr Env
env String
input =
  String -> EvalM TopExpr
readTopExpr String
input EvalM TopExpr
-> (TopExpr -> EvalM (Maybe EgisonValue, Env))
-> EvalM (Maybe EgisonValue, Env)
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Env -> TopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr Env
env

-- | Evaluate an Egison top expression. Input is a Haskell string.
runTopExprStr :: Env -> String -> EvalM (Maybe String, Env)
runTopExprStr :: Env -> String -> EvalM (Maybe String, Env)
runTopExprStr Env
env String
input =
  String -> EvalM TopExpr
readTopExpr String
input EvalM TopExpr
-> (TopExpr -> EvalM (Maybe String, Env))
-> EvalM (Maybe String, Env)
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Env -> TopExpr -> EvalM (Maybe String, Env)
evalTopExprStr Env
env

-- | Evaluate Egison top expressions. Input is a Haskell string.
runTopExprs :: Env -> String -> EvalM Env
runTopExprs :: Env -> String -> EvalM Env
runTopExprs Env
env String
input =
  String -> EvalM [TopExpr]
readTopExprs String
input EvalM [TopExpr] -> ([TopExpr] -> EvalM Env) -> EvalM Env
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Env -> [TopExpr] -> EvalM Env
evalTopExprs Env
env

-- | Load an Egison file.
loadEgisonFile :: Env -> FilePath -> EvalM Env
loadEgisonFile :: Env -> String -> EvalM Env
loadEgisonFile Env
env String
path = do
  (Maybe EgisonValue
_, Env
env') <- Env -> TopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr Env
env (String -> TopExpr
LoadFile String
path)
  Env -> EvalM Env
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Env
env'

-- | Load an Egison library.
loadEgisonLibrary :: Env -> FilePath -> EvalM Env
loadEgisonLibrary :: Env -> String -> EvalM Env
loadEgisonLibrary Env
env String
path = do
  (Maybe EgisonValue
_, Env
env') <- Env -> TopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr Env
env (String -> TopExpr
Load String
path)
  Env -> EvalM Env
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Env
env'


--
-- Helper functions
--

collectDefs :: EgisonOpts -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs :: EgisonOpts -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs EgisonOpts
opts [ITopExpr]
exprs = EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts [ITopExpr]
exprs [] []
  where
    collectDefs' :: EgisonOpts -> [ITopExpr] -> [(Var, IExpr)] -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
    collectDefs' :: EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts (ITopExpr
expr:[ITopExpr]
exprs) [(Var, IExpr)]
bindings [ITopExpr]
rest =
      case ITopExpr
expr of
        IDefine Var
name IExpr
expr -> EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts [ITopExpr]
exprs ((Var
name, IExpr
expr) (Var, IExpr) -> [(Var, IExpr)] -> [(Var, IExpr)]
forall a. a -> [a] -> [a]
: [(Var, IExpr)]
bindings) [ITopExpr]
rest
        ITest{}     -> EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts [ITopExpr]
exprs [(Var, IExpr)]
bindings (ITopExpr
expr ITopExpr -> [ITopExpr] -> [ITopExpr]
forall a. a -> [a] -> [a]
: [ITopExpr]
rest)
        IExecute{}  -> EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts [ITopExpr]
exprs [(Var, IExpr)]
bindings (ITopExpr
expr ITopExpr -> [ITopExpr] -> [ITopExpr]
forall a. a -> [a] -> [a]
: [ITopExpr]
rest)
        ILoadFile String
_ | EgisonOpts -> Bool
optNoIO EgisonOpts
opts -> EgisonError -> EvalM ([(Var, IExpr)], [ITopExpr])
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (String -> EgisonError
Default String
"No IO support")
        ILoadFile String
file -> do
          [ITopExpr]
exprs' <- String -> EvalM [TopExpr]
loadFile String
file EvalM [TopExpr]
-> ([TopExpr] -> EvalM [ITopExpr]) -> EvalM [ITopExpr]
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [TopExpr] -> EvalM [ITopExpr]
desugarTopExprs
          EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts ([ITopExpr]
exprs' [ITopExpr] -> [ITopExpr] -> [ITopExpr]
forall a. [a] -> [a] -> [a]
++ [ITopExpr]
exprs) [(Var, IExpr)]
bindings [ITopExpr]
rest
        ILoad String
_ | EgisonOpts -> Bool
optNoIO EgisonOpts
opts -> EgisonError -> EvalM ([(Var, IExpr)], [ITopExpr])
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (String -> EgisonError
Default String
"No IO support")
        ILoad String
file -> do
          [ITopExpr]
exprs' <- String -> EvalM [TopExpr]
loadLibraryFile String
file EvalM [TopExpr]
-> ([TopExpr] -> EvalM [ITopExpr]) -> EvalM [ITopExpr]
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [TopExpr] -> EvalM [ITopExpr]
desugarTopExprs
          EgisonOpts
-> [ITopExpr]
-> [(Var, IExpr)]
-> [ITopExpr]
-> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs' EgisonOpts
opts ([ITopExpr]
exprs' [ITopExpr] -> [ITopExpr] -> [ITopExpr]
forall a. [a] -> [a] -> [a]
++ [ITopExpr]
exprs) [(Var, IExpr)]
bindings [ITopExpr]
rest
    collectDefs' EgisonOpts
_ [] [(Var, IExpr)]
bindings [ITopExpr]
rest = ([(Var, IExpr)], [ITopExpr]) -> EvalM ([(Var, IExpr)], [ITopExpr])
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(Var, IExpr)]
bindings, [ITopExpr] -> [ITopExpr]
forall a. [a] -> [a]
reverse [ITopExpr]
rest)

evalTopExpr' :: Env -> ITopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr' :: Env -> ITopExpr -> EvalM (Maybe EgisonValue, Env)
evalTopExpr' Env
env (IDefine Var
name IExpr
expr) = do
  Env
env' <- Env -> [(Var, IExpr)] -> EvalM Env
recursiveBind Env
env [(Var
name, IExpr
expr)]
  (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe EgisonValue
forall a. Maybe a
Nothing, Env
env')
evalTopExpr' Env
env (ITest IExpr
expr) = do
  Var -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (m :: * -> *). MonadEval m => Var -> m ()
pushFuncName (String -> Var
stringToVar String
"<stdin>")
  EgisonValue
val <- Env -> IExpr -> EvalM EgisonValue
evalExprDeep Env
env IExpr
expr
  StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (m :: * -> *). MonadEval m => m ()
popFuncName
  (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (EgisonValue -> Maybe EgisonValue
forall a. a -> Maybe a
Just EgisonValue
val, Env
env)
evalTopExpr' Env
env (IExecute IExpr
expr) = do
  Var -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (m :: * -> *). MonadEval m => Var -> m ()
pushFuncName (String -> Var
stringToVar String
"<stdin>")
  WHNFData
io <- Env -> IExpr -> EvalM WHNFData
evalExprShallow Env
env IExpr
expr
  case WHNFData
io of
    Value (IOFunc EvalM WHNFData
m) -> EvalM WHNFData
m EvalM WHNFData
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (m :: * -> *). MonadEval m => m ()
popFuncName StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> EvalM (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe EgisonValue
forall a. Maybe a
Nothing, Env
env)
    WHNFData
_                -> (CallStack -> EgisonError) -> EvalM (Maybe EgisonValue, Env)
forall a. (CallStack -> EgisonError) -> EvalM a
throwErrorWithTrace (String -> WHNFData -> CallStack -> EgisonError
TypeMismatch String
"io" WHNFData
io)
evalTopExpr' Env
env (ILoad String
file) = do
  EgisonOpts
opts <- StateT EvalState (ExceptT EgisonError RuntimeM) EgisonOpts
forall r (m :: * -> *). MonadReader r m => m r
ask
  Bool
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (EgisonOpts -> Bool
optNoIO EgisonOpts
opts) (StateT EvalState (ExceptT EgisonError RuntimeM) ()
 -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b. (a -> b) -> a -> b
$ EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (String -> EgisonError
Default String
"No IO support")
  [ITopExpr]
exprs <- String -> EvalM [TopExpr]
loadLibraryFile String
file EvalM [TopExpr]
-> ([TopExpr] -> EvalM [ITopExpr]) -> EvalM [ITopExpr]
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [TopExpr] -> EvalM [ITopExpr]
desugarTopExprs
  ([(Var, IExpr)]
bindings, [ITopExpr]
_) <- EgisonOpts -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs EgisonOpts
opts [ITopExpr]
exprs
  Env
env' <- Env -> [(Var, IExpr)] -> EvalM Env
recursiveBind Env
env [(Var, IExpr)]
bindings
  (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe EgisonValue
forall a. Maybe a
Nothing, Env
env')
evalTopExpr' Env
env (ILoadFile String
file) = do
  EgisonOpts
opts <- StateT EvalState (ExceptT EgisonError RuntimeM) EgisonOpts
forall r (m :: * -> *). MonadReader r m => m r
ask
  Bool
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (EgisonOpts -> Bool
optNoIO EgisonOpts
opts) (StateT EvalState (ExceptT EgisonError RuntimeM) ()
 -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b. (a -> b) -> a -> b
$ EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (String -> EgisonError
Default String
"No IO support")
  [ITopExpr]
exprs <- String -> EvalM [TopExpr]
loadFile String
file EvalM [TopExpr]
-> ([TopExpr] -> EvalM [ITopExpr]) -> EvalM [ITopExpr]
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [TopExpr] -> EvalM [ITopExpr]
desugarTopExprs
  ([(Var, IExpr)]
bindings, [ITopExpr]
_) <- EgisonOpts -> [ITopExpr] -> EvalM ([(Var, IExpr)], [ITopExpr])
collectDefs EgisonOpts
opts [ITopExpr]
exprs
  Env
env' <- Env -> [(Var, IExpr)] -> EvalM Env
recursiveBind Env
env [(Var, IExpr)]
bindings
  (Maybe EgisonValue, Env) -> EvalM (Maybe EgisonValue, Env)
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe EgisonValue
forall a. Maybe a
Nothing, Env
env')