Portability | portable |
---|---|
Stability | experimental |
Maintainer | github.com/justinethier |
Safe Haskell | Safe-Inferred |
This module contains top-level data type definitions, environments, error types, and associated functions.
- data Env = Environment {}
- nullEnv :: IO Env
- data LispError
- type ThrowsError = Either LispError
- trapError :: (MonadError e m, Show e) => m String -> m String
- extractValue :: ThrowsError a -> a
- type IOThrowsError = ErrorT LispError IO
- liftThrows :: ThrowsError a -> IOThrowsError a
- runIOThrowsREPL :: IOThrowsError String -> IO String
- runIOThrows :: IOThrowsError String -> IO (Maybe String)
- data LispVal
- = Atom String
- | List [LispVal]
- | DottedList [LispVal] LispVal
- | Vector (Array Int LispVal)
- | HashTable (Map LispVal LispVal)
- | Number Integer
- | Float Double
- | Complex (Complex Double)
- | Rational Rational
- | String String
- | Char Char
- | Bool Bool
- | PrimitiveFunc ([LispVal] -> ThrowsError LispVal)
- | Func { }
- | HFunc { }
- | IOFunc ([LispVal] -> IOThrowsError LispVal)
- | EvalFunc ([LispVal] -> IOThrowsError LispVal)
- | Pointer {
- pointerVar :: String
- pointerEnv :: Env
- | Opaque Dynamic
- | Port Handle
- | Continuation { }
- | Syntax {
- synClosure :: Maybe Env
- synRenameClosure :: Maybe Env
- synDefinedInMacro :: Bool
- synIdentifiers :: [LispVal]
- synRules :: [LispVal]
- | SyntaxExplicitRenaming LispVal
- | EOF
- | Nil String
- toOpaque :: Typeable a => a -> LispVal
- fromOpaque :: forall a. Typeable a => LispVal -> ThrowsError a
- data DeferredCode
- = SchemeBody [LispVal]
- | HaskellBody {
- contFunction :: Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal
- contFunctionArgs :: Maybe [LispVal]
- data DynamicWinders = DynamicWinders {}
- makeNullContinuation :: Env -> LispVal
- makeCPS :: Env -> LispVal -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> LispVal
- makeCPSWArgs :: Env -> LispVal -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> [LispVal] -> LispVal
- eqv :: [LispVal] -> ThrowsError LispVal
- eqvList :: ([LispVal] -> ThrowsError LispVal) -> [LispVal] -> ThrowsError LispVal
- eqVal :: LispVal -> LispVal -> Bool
- makeFunc :: Monad m => Maybe String -> Env -> [LispVal] -> [LispVal] -> m LispVal
- makeNormalFunc :: Monad m => Env -> [LispVal] -> [LispVal] -> m LispVal
- makeVarargs :: Monad m => LispVal -> Env -> [LispVal] -> [LispVal] -> m LispVal
- makeHFunc :: Monad m => Maybe String -> Env -> [String] -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> m LispVal
- makeNormalHFunc :: Monad m => Env -> [String] -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> m LispVal
- makeHVarargs :: Monad m => LispVal -> Env -> [String] -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> m LispVal
Documentation
A Scheme environment containing variable bindings of form (namespaceName, variableName), variableValue
Types of errors that may occur when evaluating Scheme code
NumArgs Integer [LispVal] | Invalid number of function arguments |
TypeMismatch String LispVal | Type error |
Parser ParseError | Parsing error |
BadSpecialForm String LispVal | Invalid special (built-in) form |
NotFunction String String | |
UnboundVar String String | |
DivideByZero | Divide by Zero error |
NotImplemented String | |
InternalError String | An internal error within husk; in theory user (Scheme) code should never allow one of these errors to be triggered. |
Default String | Default error |
type ThrowsError = Either LispErrorSource
extractValue :: ThrowsError a -> aSource
type IOThrowsError = ErrorT LispError IOSource
liftThrows :: ThrowsError a -> IOThrowsError aSource
runIOThrowsREPL :: IOThrowsError String -> IO StringSource
Execute an IO action and return result or an error message. This is intended for use by a REPL, where a result is always needed regardless of type.
runIOThrows :: IOThrowsError String -> IO (Maybe String)Source
Execute an IO action and return error or Nothing if no error was thrown.
Scheme data types
Atom String | Symbol |
List [LispVal] | List |
DottedList [LispVal] LispVal | Pair |
Vector (Array Int LispVal) | Vector |
HashTable (Map LispVal LispVal) | Hash table. Technically this could be a derived data type instead of being built-in to the interpreter. And perhaps in the future it will be. But for now, a hash table is too important of a data type to not be included. |
Number Integer | |
Float Double | |
Complex (Complex Double) | Complex number |
Rational Rational | Rational number |
String String | String |
Char Char | Character |
Bool Bool | Boolean |
PrimitiveFunc ([LispVal] -> ThrowsError LispVal) | Primitive function |
Func | Function |
HFunc | Function formed from a Haskell function |
IOFunc ([LispVal] -> IOThrowsError LispVal) | Primitive function within the IO monad |
EvalFunc ([LispVal] -> IOThrowsError LispVal) | Function within the IO monad with access to the current environment and continuation. |
Pointer | Pointer to an environment variable. |
| |
Opaque Dynamic | Opaque Haskell value. |
Port Handle | I/O port |
Continuation | Continuation |
| |
Syntax | Type to hold a syntax object that is created by a macro definition. Syntax objects are not used like regular types in that they are not passed around within variables. In other words, you cannot use set! to assign a variable to a syntax object. But they are used during function application. In any case, it is convenient to define the type here because syntax objects are stored in the same environments and manipulated by the same functions as regular variables. |
| |
SyntaxExplicitRenaming LispVal | Syntax for an explicit-renaming macro |
EOF | |
Nil String | Internal use only; do not use this type directly. |
fromOpaque :: forall a. Typeable a => LispVal -> ThrowsError aSource
Convert an opaque Lisp value back into a Haskell value of the appropriate type, or produce a TypeMismatch error.
data DeferredCode Source
Container to hold code that is passed to a continuation for deferred execution
SchemeBody [LispVal] | A block of Scheme code |
HaskellBody | A Haskell function |
|
makeCPS :: Env -> LispVal -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> LispValSource
makeCPSWArgs :: Env -> LispVal -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> [LispVal] -> LispValSource
eqvList :: ([LispVal] -> ThrowsError LispVal) -> [LispVal] -> ThrowsError LispValSource
Compare two lists of haskell values, using the given comparison function
makeFunc :: Monad m => Maybe String -> Env -> [LispVal] -> [LispVal] -> m LispValSource
Create a scheme function
makeNormalFunc :: Monad m => Env -> [LispVal] -> [LispVal] -> m LispValSource
Create a normal scheme function
makeVarargs :: Monad m => LispVal -> Env -> [LispVal] -> [LispVal] -> m LispValSource
Create a scheme function that can receive any number of arguments
makeHFunc :: Monad m => Maybe String -> Env -> [String] -> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal) -> m LispValSource
Create a haskell function