Expresso

A simple expressions language with polymorphic extensible row types.

This module is the public API for Expresso.

Documentation

data Bind v

Binders

Constructors

Arg v

RecArg [v]

RecWildcard

Instances

Show v => Show (Bind v)

Defined in Expresso.Syntax

Methods

showsPrec :: Int -> Bind v -> ShowS

show :: Bind v -> String

showList :: [Bind v] -> ShowS

data Env

A call-by-need environment. Using a HashMap makes it easy to support record wildcards.

Instances

Semigroup Env

Defined in Expresso.Eval

Methods

(<>) :: Env -> Env -> Env

sconcat :: NonEmpty Env -> Env

stimes :: Integral b => b -> Env -> Env

Monoid Env

Defined in Expresso.Eval

Methods

mempty :: Env

mappend :: Env -> Env -> Env

mconcat :: [Env] -> Env

data Environments

Type and term environments.

type Exp = Fix (ExpF Name Bind Type :*: K Pos)

Expressions with imports resolved.

data ExpF v b t r

Pattern functor representing expressions and parameterised with the type of variable v, type of binder b and the type of type-annotation t.

Constructors

EVar v

EPrim Prim

EApp r r

ELam (b v) r

EAnnLam (b v) t r

ELet (b v) r r

EAnn r t

Instances

Functor (ExpF v b t)

Defined in Expresso.Syntax

Methods

fmap :: (a -> b0) -> ExpF v b t a -> ExpF v b t b0

(<$) :: a -> ExpF v b t b0 -> ExpF v b t a

Foldable (ExpF v b t)

Defined in Expresso.Syntax

Methods

fold :: Monoid m => ExpF v b t m -> m

foldMap :: Monoid m => (a -> m) -> ExpF v b t a -> m

foldr :: (a -> b0 -> b0) -> b0 -> ExpF v b t a -> b0

foldr' :: (a -> b0 -> b0) -> b0 -> ExpF v b t a -> b0

foldl :: (b0 -> a -> b0) -> b0 -> ExpF v b t a -> b0

foldl' :: (b0 -> a -> b0) -> b0 -> ExpF v b t a -> b0

foldr1 :: (a -> a -> a) -> ExpF v b t a -> a

foldl1 :: (a -> a -> a) -> ExpF v b t a -> a

toList :: ExpF v b t a -> [a]

null :: ExpF v b t a -> Bool

length :: ExpF v b t a -> Int

elem :: Eq a => a -> ExpF v b t a -> Bool

maximum :: Ord a => ExpF v b t a -> a

minimum :: Ord a => ExpF v b t a -> a

sum :: Num a => ExpF v b t a -> a

product :: Num a => ExpF v b t a -> a

Traversable (ExpF v b t)

Defined in Expresso.Syntax

Methods

traverse :: Applicative f => (a -> f b0) -> ExpF v b t a -> f (ExpF v b t b0)

sequenceA :: Applicative f => ExpF v b t (f a) -> f (ExpF v b t a)

mapM :: Monad m => (a -> m b0) -> ExpF v b t a -> m (ExpF v b t b0)

sequence :: Monad m => ExpF v b t (m a) -> m (ExpF v b t a)

(Show v, Show r, Show t, Show (b v)) => Show (ExpF v b t r)

Defined in Expresso.Syntax

Methods

showsPrec :: Int -> ExpF v b t r -> ShowS

show :: ExpF v b t r -> String

showList :: [ExpF v b t r] -> ShowS

type ExpI = Fix ((ExpF Name Bind Type :+: K Import) :*: K Pos)

Expressions with imports.

class HasValue a where

A class of Haskell types that can be projected from or injected into Expresso values.

Methods

proj :: Value -> EvalM a

inj :: a -> Value

Instances

HasValue Bool

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Bool

inj :: Bool -> Value

HasValue Char

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Char

inj :: Char -> Value

HasValue Double

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Double

inj :: Double -> Value

HasValue Integer

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Integer

inj :: Integer -> Value

HasValue String

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM String

inj :: String -> Value

HasValue Text

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Text

inj :: Text -> Value

HasValue Value

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Value

inj :: Value -> Value

HasValue a => HasValue [(Name, a)]

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM [(Name, a)]

inj :: [(Name, a)] -> Value

HasValue [(Name, Thunk)]

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM [(Name, Thunk)]

inj :: [(Name, Thunk)] -> Value

HasValue a => HasValue [a]

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM [a]

inj :: [a] -> Value

HasValue [Value]

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM [Value]

inj :: [Value] -> Value

HasValue a => HasValue (Maybe a)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (Maybe a)

inj :: Maybe a -> Value

(HasValue a, HasValue b, HasValue c, HasValue d) => HasValue (a -> b -> c -> IO d)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (a -> b -> c -> IO d)

inj :: (a -> b -> c -> IO d) -> Value

(HasValue a, HasValue b, HasValue c) => HasValue (a -> b -> IO c)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (a -> b -> IO c)

inj :: (a -> b -> IO c) -> Value

(HasValue a, HasValue b) => HasValue (a -> IO b)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (a -> IO b)

inj :: (a -> IO b) -> Value

(HasValue a, HasValue b, HasValue c, HasValue d) => HasValue (a -> b -> c -> d)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (a -> b -> c -> d)

inj :: (a -> b -> c -> d) -> Value

(HasValue a, HasValue b, HasValue c) => HasValue (a -> b -> c)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (a -> b -> c)

inj :: (a -> b -> c) -> Value

(HasValue a, HasValue b) => HasValue (a -> b)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (a -> b)

inj :: (a -> b) -> Value

HasValue a => HasValue (HashMap Name a)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (HashMap Name a)

inj :: HashMap Name a -> Value

HasValue (HashMap Name Thunk)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (HashMap Name Thunk)

inj :: HashMap Name Thunk -> Value

newtype Import

An import file path.

Constructors

Import

Fields

• unImport :: FilePath

type Name = String

A string representing a unique name.

newtype Thunk

A potentially unevaluated value.

Constructors

Thunk

Fields

• force :: EvalM Value

Instances

Show Thunk

Defined in Expresso.Eval

Methods

showsPrec :: Int -> Thunk -> ShowS

show :: Thunk -> String

showList :: [Thunk] -> ShowS

HasValue [(Name, Thunk)]

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM [(Name, Thunk)]

inj :: [(Name, Thunk)] -> Value

HasValue (HashMap Name Thunk)

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM (HashMap Name Thunk)

inj :: HashMap Name Thunk -> Value

data TIState

Internal state of the inference engine.

type Type = Fix (TypeF :*: K Pos)

Type syntax annotated with source position.

pattern TForAll :: forall a. View TypeF a => [TyVar] -> a -> a

pattern TVar :: forall a. View TypeF a => TyVar -> a

pattern TMetaVar :: forall a. View TypeF a => MetaTv -> a

pattern TInt :: forall a. View TypeF a => a

pattern TDbl :: forall a. View TypeF a => a

pattern TBool :: forall a. View TypeF a => a

pattern TChar :: forall a. View TypeF a => a

pattern TText :: forall a. View TypeF a => a

pattern TFun :: forall a. View TypeF a => a -> a -> a

pattern TList :: forall a. View TypeF a => a -> a

pattern TRecord :: forall a. View TypeF a => a -> a

pattern TVariant :: forall a. View TypeF a => a -> a

pattern TRowEmpty :: forall a. View TypeF a => a

pattern TRowExtend :: forall a. View TypeF a => Label -> a -> a -> a

data TypeF r

Pattern functor for the syntax of types.

Constructors

TForAllF [TyVar] r

TVarF TyVar

TMetaVarF MetaTv

TIntF

TDblF

TBoolF

TCharF

TTextF

TFunF r r

TListF r

TRecordF r

TVariantF r

TRowEmptyF

TRowExtendF Label r r

Instances

Functor TypeF

Defined in Expresso.Type

Methods

fmap :: (a -> b) -> TypeF a -> TypeF b

(<$) :: a -> TypeF b -> TypeF a

Foldable TypeF

Defined in Expresso.Type

Methods

fold :: Monoid m => TypeF m -> m

foldMap :: Monoid m => (a -> m) -> TypeF a -> m

foldr :: (a -> b -> b) -> b -> TypeF a -> b

foldr' :: (a -> b -> b) -> b -> TypeF a -> b

foldl :: (b -> a -> b) -> b -> TypeF a -> b

foldl' :: (b -> a -> b) -> b -> TypeF a -> b

foldr1 :: (a -> a -> a) -> TypeF a -> a

foldl1 :: (a -> a -> a) -> TypeF a -> a

toList :: TypeF a -> [a]

null :: TypeF a -> Bool

length :: TypeF a -> Int

elem :: Eq a => a -> TypeF a -> Bool

maximum :: Ord a => TypeF a -> a

minimum :: Ord a => TypeF a -> a

sum :: Num a => TypeF a -> a

product :: Num a => TypeF a -> a

Traversable TypeF

Defined in Expresso.Type

Methods

traverse :: Applicative f => (a -> f b) -> TypeF a -> f (TypeF b)

sequenceA :: Applicative f => TypeF (f a) -> f (TypeF a)

mapM :: Monad m => (a -> m b) -> TypeF a -> m (TypeF b)

sequence :: Monad m => TypeF (m a) -> m (TypeF a)

Eq r => Eq (TypeF r)

Defined in Expresso.Type

Methods

(==) :: TypeF r -> TypeF r -> Bool

(/=) :: TypeF r -> TypeF r -> Bool

Data r => Data (TypeF r)

Defined in Expresso.Type

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeF r -> c (TypeF r)

gunfold :: (forall b r0. Data b => c (b -> r0) -> c r0) -> (forall r1. r1 -> c r1) -> Constr -> c (TypeF r)

toConstr :: TypeF r -> Constr

dataTypeOf :: TypeF r -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TypeF r))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeF r))

gmapT :: (forall b. Data b => b -> b) -> TypeF r -> TypeF r

gmapQl :: (r0 -> r' -> r0) -> r0 -> (forall d. Data d => d -> r') -> TypeF r -> r0

gmapQr :: (r' -> r0 -> r0) -> r0 -> (forall d. Data d => d -> r') -> TypeF r -> r0

gmapQ :: (forall d. Data d => d -> u) -> TypeF r -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeF r -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeF r -> m (TypeF r)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeF r -> m (TypeF r)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeF r -> m (TypeF r)

Ord r => Ord (TypeF r)

Defined in Expresso.Type

Methods

compare :: TypeF r -> TypeF r -> Ordering

(<) :: TypeF r -> TypeF r -> Bool

(<=) :: TypeF r -> TypeF r -> Bool

(>) :: TypeF r -> TypeF r -> Bool

(>=) :: TypeF r -> TypeF r -> Bool

max :: TypeF r -> TypeF r -> TypeF r

min :: TypeF r -> TypeF r -> TypeF r

Show r => Show (TypeF r)

Defined in Expresso.Type

Methods

showsPrec :: Int -> TypeF r -> ShowS

show :: TypeF r -> String

showList :: [TypeF r] -> ShowS

data TypeEnv

The type environment.

Instances

Semigroup TypeEnv

Defined in Expresso.Type

Methods

(<>) :: TypeEnv -> TypeEnv -> TypeEnv

sconcat :: NonEmpty TypeEnv -> TypeEnv

stimes :: Integral b => b -> TypeEnv -> TypeEnv

Monoid TypeEnv

Defined in Expresso.Type

Methods

mempty :: TypeEnv

mappend :: TypeEnv -> TypeEnv -> TypeEnv

mconcat :: [TypeEnv] -> TypeEnv

data Value

Type for an evaluated term.

Constructors

VLam !(Thunk -> EvalM Value)

VInt !Integer

VDbl !Double

VBool !Bool

VChar !Char

VText !Text

VList ![Value]

VRecord !(HashMap Label Thunk)

VVariant !Label !Thunk

Instances

HasValue Value

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM Value

inj :: Value -> Value

HasValue [Value]

Defined in Expresso.Eval

Methods

proj :: Value -> EvalM [Value]

inj :: [Value] -> Value

bind :: Environments -> Bind Name -> ExpI -> EvalM Environments

Used by the REPL to bind variables.

dummyPos :: Pos

A useless source position.

evalFile :: HasValue a => Maybe Type -> FilePath -> IO (Either String a)

Evaluate the contents of the supplied file path; and optionally validate using a supplied type (schema).

evalFile' :: HasValue a => Environments -> Maybe Type -> FilePath -> IO (Either String a)

Evaluate the contents of the supplied file path; and optionally validate using a supplied type (schema). NOTE: This version also takes a term environment and a type environment so that foreign functions and their types can be installed respectively.

evalString :: HasValue a => Maybe Type -> String -> IO (Either String a)

Parse an expression and evaluate it; optionally validate using a supplied type (schema).

evalString' :: HasValue a => Environments -> Maybe Type -> String -> IO (Either String a)

Parse an expression and evaluate it; optionally validate using a supplied type (schema). NOTE: This version also takes a term environment and a type environment so that foreign functions and their types can be installed respectively.

evalWithEnv :: HasValue a => Environments -> ExpI -> IO (Either String a)

Evaluate an expression using the supplied type and term environments.

initEnvironments :: Environments

Empty initial type and term environments.

installBinding :: Name -> Type -> Value -> Environments -> Environments

Install a binding using the supplied name, type and term. Useful for extending the set of built-in functions.

runEvalM :: EvalM a -> IO (Either String a)

Run the EvalM evaluation computation.

showType :: Type -> String

Pretty print the supplied type.

showValue :: Value -> String

Pretty print the supplied value. This does *not* evaluate deeply.

showValue' :: Value -> IO String

Pretty print the supplied value. This evaluates deeply.

dumpTypeEnv :: Environments -> [(Name, Sigma)]

Extract type environment bindings.

typeOf :: ExpI -> IO (Either String Type)

Query the type of an expression.

typeOfString :: String -> IO (Either String Type)

Parse an expression and query its type.

typeOfWithEnv :: Environments -> ExpI -> IO (Either String Type)

Query the type of an expression using the supplied type environment.

validate :: Type -> ExpI -> ExpI

Add a validating type signature section to the supplied expression.

choice :: HasValue a => [(Name, Value -> EvalM a)] -> Value -> EvalM a

Convenience for implementing proj for a sum type.

mkRecord :: [(Name, Thunk)] -> Value

Convenience constructor for a record value.

mkStrictLam :: (Value -> EvalM Value) -> Value

Make a strict Expresso lambda value (forced arguments) from a Haskell function (on Expresso values).

mkStrictLam2 :: (Value -> Value -> EvalM Value) -> Value

As mkStrictLam, but accepts Haskell functions with two curried arguments.

mkStrictLam3 :: (Value -> Value -> Value -> EvalM Value) -> Value

As mkStrictLam, but accepts Haskell functions with three curried arguments.

mkVariant :: Name -> Value -> Value

Convenience constructor for a variant value.

typeMismatch :: String -> Value -> EvalM a

Throw a type mismatch error.

unit :: Value

Unit value. Equivalent to () in Haskell.

(.:) :: HasValue a => Value -> Name -> EvalM a

Project out a record field, fail with a type mismatch if it is not present.

(.=) :: Name -> Value -> (Name, Thunk)

Pair up a field name and a value. Intended to be used with mkRecord or mkVariant.