Copyright	Justin Ethier
License	MIT (see LICENSE in the distribution)
Maintainer	github.com/justinethier
Stability	experimental
Portability	portable
Safe Haskell	None
Language	Haskell2010

Language.Scheme.Types

Contents

Environments
Error Handling
Types and related functions

Description

This module contains top-level data type definitions, environments, error types, and associated functions.

Synopsis

data Env = Environment {
- parentEnv :: Maybe Env
- bindings :: IORef (Map String (IORef LispVal))
- pointers :: IORef (Map String (IORef [LispVal]))
}
nullEnv :: IO Env
data LispError
- = NumArgs (Maybe Integer) [LispVal]
- | TypeMismatch String LispVal
- | Parser ParseError
- | BadSpecialForm String LispVal
- | UnboundVar String String
- | DivideByZero
- | NotImplemented String
- | InternalError String
- | Default String
- | ErrorWithCallHist LispError [LispVal]
type ThrowsError = Either LispError
type IOThrowsError = ExceptT LispError IO
liftThrows :: ThrowsError a -> IOThrowsError a
showCallHistory :: String -> [LispVal] -> String
data LispVal
- = Atom String
- | List [LispVal]
- | DottedList [LispVal] LispVal
- | Vector (Array Int LispVal)
- | ByteVector ByteString
- | HashTable (Map LispVal LispVal)
- | Number Integer
- | Float Double
- | Complex (Complex Double)
- | Rational Rational
- | String String
- | Char Char
- | Bool Bool
- | PrimitiveFunc ([LispVal] -> ThrowsError LispVal)
- | Func {
  - params :: [String]
  - vararg :: Maybe String
  - body :: [LispVal]
  - closure :: Env
  }
- | HFunc {
  - hparams :: [String]
  - hvararg :: Maybe String
  - hbody :: Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal
  - hclosure :: Env
  }
- | IOFunc ([LispVal] -> IOThrowsError LispVal)
- | EvalFunc ([LispVal] -> IOThrowsError LispVal)
- | CustFunc ([LispVal] -> IOThrowsError LispVal)
- | Pointer {
  - pointerVar :: String
  - pointerEnv :: Env
  }
- | Opaque Dynamic
- | Port Handle (Maybe Knob)
- | Continuation {
  - contClosure :: Env
  - currentCont :: Maybe DeferredCode
  - nextCont :: Maybe LispVal
  - dynamicWind :: Maybe [DynamicWinders]
  - contCallHist :: [LispVal]
  }
- | Syntax {
  - synClosure :: Maybe Env
  - synRenameClosure :: Maybe Env
  - synDefinedInMacro :: Bool
  - synEllipsis :: String
  - synIdentifiers :: [LispVal]
  - synRules :: [LispVal]
  }
- | SyntaxExplicitRenaming LispVal
- | LispEnv Env
- | EOF
- | Nil String
nullLisp :: LispVal
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 {
- before :: LispVal
- after :: LispVal
}
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
box :: LispVal -> IOThrowsError [LispVal]
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
validateFuncParams :: [LispVal] -> Maybe Integer -> IOThrowsError Bool

Environments

data Env Source #

A Scheme environment containing variable bindings of form (namespaceName, variableName), variableValue

Constructors

Environment
Fields parentEnv :: Maybe Env bindings :: IORef (Map String (IORef LispVal)) pointers :: IORef (Map String (IORef [LispVal]))

Instances

Instances details

Eq Env Source #
Instance details Defined in Language.Scheme.Types Methods (==) :: Env -> Env -> Bool # (/=) :: Env -> Env -> Bool #

nullEnv :: IO Env Source #

An empty environment

Error Handling

data LispError Source #

Types of errors that may occur when evaluating Scheme code

Constructors

NumArgs (Maybe Integer) [LispVal]	Invalid number of function arguments
TypeMismatch String LispVal	Type error
Parser ParseError	Parsing error
BadSpecialForm String LispVal	Invalid special (built-in) form
UnboundVar String String	A referenced variable has not been declared
DivideByZero	Divide by Zero error
NotImplemented String	Feature is not implemented
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
ErrorWithCallHist LispError [LispVal]	Wraps an error to also include the current call history

Instances

Instances details

Show LispError Source #
Instance details Defined in Language.Scheme.Types Methods showsPrec :: Int -> LispError -> ShowS # show :: LispError -> String # showList :: [LispError] -> ShowS #

type ThrowsError = Either LispError Source #

Container used by operations that could throw an error

type IOThrowsError = ExceptT LispError IO Source #

Container used to provide error handling in the IO monad

liftThrows :: ThrowsError a -> IOThrowsError a Source #

Lift a ThrowsError into the IO monad

showCallHistory :: String -> [LispVal] -> String Source #

Display call history for an error

Types and related functions

data LispVal Source #

Scheme data types

Constructors

Atom String	Symbol
List [LispVal]	List
DottedList [LispVal] LispVal	Pair
Vector (Array Int LispVal)	Vector
ByteVector ByteString	ByteVector from R7RS
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	Integer number
Float Double	Double-precision floating point number
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 written in Scheme
Fields params :: [String] vararg :: Maybe String body :: [LispVal] closure :: Env
HFunc	Function formed from a Haskell function
Fields hparams :: [String] hvararg :: Maybe String hbody :: Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal hclosure :: Env
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.
CustFunc ([LispVal] -> IOThrowsError LispVal)	A custom function written by code outside of husk. Any code that uses the Haskell API should define custom functions using this data type.
Pointer	Pointer to an environment variable.
Fields pointerVar :: String pointerEnv :: Env
Opaque Dynamic	Opaque Haskell value.
Port Handle (Maybe Knob)	I/O port
Continuation	Continuation
Fields contClosure :: Env currentCont :: Maybe DeferredCode nextCont :: Maybe LispVal dynamicWind :: Maybe [DynamicWinders] contCallHist :: [LispVal]
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.
Fields synClosure :: Maybe Env Code env in effect at definition time, if applicable synRenameClosure :: Maybe Env Renames (from macro hygiene) in effect at def time; only applicable if this macro defined inside another macro. synDefinedInMacro :: Bool Set if macro is defined within another macro synEllipsis :: String String to use as the ellipsis identifier synIdentifiers :: [LispVal] Literal identifiers from syntax-rules synRules :: [LispVal] Rules from syntax-rules
SyntaxExplicitRenaming LispVal	Syntax for an explicit-renaming macro
LispEnv Env	Wrapper for a scheme environment
EOF	End of file indicator
Nil String	Internal use only; do not use this type directly.

Instances

Instances details

Eq LispVal Source #
Instance details Defined in Language.Scheme.Types Methods (==) :: LispVal -> LispVal -> Bool # (/=) :: LispVal -> LispVal -> Bool #
Ord LispVal Source #
Instance details Defined in Language.Scheme.Types Methods compare :: LispVal -> LispVal -> Ordering # (<) :: LispVal -> LispVal -> Bool # (<=) :: LispVal -> LispVal -> Bool # (>) :: LispVal -> LispVal -> Bool # (>=) :: LispVal -> LispVal -> Bool # max :: LispVal -> LispVal -> LispVal # min :: LispVal -> LispVal -> LispVal #
Show LispVal Source #	Allow conversion of lispval instances to strings
Instance details Defined in Language.Scheme.Types Methods showsPrec :: Int -> LispVal -> ShowS # show :: LispVal -> String # showList :: [LispVal] -> ShowS #

nullLisp :: LispVal Source #

Scheme null value

toOpaque :: Typeable a => a -> LispVal Source #

Convert a Haskell value to an opaque Lisp value.

fromOpaque :: forall a. Typeable a => LispVal -> ThrowsError a Source #

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

Constructors

SchemeBody [LispVal]	A block of Scheme code
HaskellBody	A Haskell function
Fields contFunction :: Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal contFunctionArgs :: Maybe [LispVal]

data DynamicWinders Source #

Container to store information from a dynamic-wind

Constructors

DynamicWinders
Fields before :: LispVal Function to execute when resuming continuation within extent of dynamic-wind after :: LispVal Function to execute when leaving extent of dynamic-wind

Instances

Instances details

Show DynamicWinders Source #
Instance details Defined in Language.Scheme.Types Methods showsPrec :: Int -> DynamicWinders -> ShowS # show :: DynamicWinders -> String # showList :: [DynamicWinders] -> ShowS #

makeNullContinuation :: Env -> LispVal Source #

Make an empty continuation that does not contain any code

makeCPS Source #

Arguments

:: Env	Environment
-> LispVal	Current continuation
-> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal)	Haskell function
-> LispVal	The Haskell function packaged as a LispVal

Make a continuation that takes a higher-order function (written in Haskell)

makeCPSWArgs Source #

Arguments

:: Env	Environment
-> LispVal	Current continuation
-> (Env -> LispVal -> LispVal -> Maybe [LispVal] -> IOThrowsError LispVal)	Haskell function
-> [LispVal]	Arguments to the function
-> LispVal	The Haskell function packaged as a LispVal