Ivory.Language.Proc

Documentation

data Proc k

The kind of procedures.

Constructors

[k] :-> k

class ProcType sig where

Typeclass for procedure types, parametrized over the C procedure's signature, to produce a value representing their signature.

Methods

procType :: Proxy sig -> (Type, [Type])

Turn a type-level description of the signature into a (return type, [argument types]) value.

Instances

(IvoryType a, ProcType ((:->) * args r)) => ProcType ((:->) * ((:) * a args) r)

IvoryType r => ProcType ((:->) * ([] *) r)

newtype ProcPtr sig

Procedure pointers

Constructors

ProcPtr

Fields

getProcPtr :: Name

Instances

ProcType proc => IvoryVar (ProcPtr proc)

ProcType proc => IvoryType (ProcPtr proc)

ProcType proc => IvoryInit (ProcPtr proc)

procPtr :: ProcType sig => Def sig -> ProcPtr sig

data Def proc

Procedure definitions.

Constructors

DefProc Proc

DefImport Import

Instances

Eq (Def proc)

Ord (Def proc)

Show (Def proc)

ProcType proc => IvoryType (Def proc)

defSymbol :: Def proc -> Name

proc :: forall proc impl. IvoryProcDef proc impl => Sym -> impl -> Def proc

Procedure definition.

voidProc :: IvoryProcDef (args :-> ()) impl => Sym -> impl -> Def (args :-> ())

Type inference can usually determine the argument types of an Ivory procedure, but for void procedures there's often nothing to constrain the return type. This function is a type-constrained version of proc that just forces the return type to be '()'.

newtype Body r

Constructors

Body

Fields

runBody :: forall s. Ivory (ProcEffects s r) ()

Instances

WrapIvory Body

IvoryType ret => IvoryProcDef ((:->) * ([] *) ret) (Body ret)

type Return Body = ()

class WrapIvory m where

Associated Types

type Return m

Methods

wrap :: (forall s. Ivory (ProcEffects s r) (Return m)) -> m r

unwrap :: m r -> forall s. Ivory (ProcEffects s r) (Return m)

Instances

WrapIvory ImportFrom

WrapIvory Body

body :: IvoryType r => (forall s. Ivory (ProcEffects s r) ()) -> Body r

data Definition

Constructors

Defined CodeBlock

Imported FilePath [Require] [Ensure]

class ProcType proc => IvoryProcDef proc impl | impl -> proc where

Typeclass for an Ivory procedure definition to produce ; the type is parametrized over:

• The procedure type proc, encoding the C procedure's signature via the Proc kind,
• The implementation type impl - either Body for the return value, or else a Haskell function type whose arguments correspond to the C arguments and whose return type is Body r on the return type r.

Methods

procDef :: Closure -> Proxy proc -> impl -> ([Var], Definition)

Instances

IvoryType ret => IvoryProcDef ((:->) * ([] *) ret) (ImportFrom ret)

IvoryType ret => IvoryProcDef ((:->) * ([] *) ret) (Body ret)

(IvoryVar a, IvoryProcDef ((:->) * args ret) k) => IvoryProcDef ((:->) * ((:) * a args) ret) (a -> k)

data Closure

A variable name supply, and the typed values that have been generated.

Constructors

Closure

Fields

closSupply :: [Var]

closEnv :: [Var]

initialClosure :: Closure

Initial closure, with no environment and a large supply of names.

genVar :: Closure -> (Var, Closure)

Given a type and a closure, generate a typed variable, and a new closure with that typed variable in it's environment.

getEnv :: Closure -> [Var]

Retrieve the environment from a closure.

importProc :: forall proc. ProcType proc => Sym -> String -> Def proc

Import a function from a C header.

newtype ImportFrom r

Constructors

ImportFrom

Fields

runImportFrom :: forall s. Ivory (ProcEffects s r) FilePath

Instances

WrapIvory ImportFrom

IvoryType ret => IvoryProcDef ((:->) * ([] *) ret) (ImportFrom ret)

type Return ImportFrom = FilePath

importFrom :: String -> ImportFrom a

call :: forall proc eff impl. IvoryCall proc eff impl => Def proc -> impl

Direct calls.

indirect :: forall proc eff impl. IvoryCall proc eff impl => ProcPtr proc -> impl

Indirect calls.

class IvoryCall proc eff impl | proc eff -> impl, impl -> eff where

Typeclass for something callable in Ivory (and returning a result). Parameter proc is the procedure type (encoding the arguments and return of the C procedure via the Proc kind, as in IvoryProcDef), parameter eff is the effect context (which remains unchanged through the calls here), and parameter impl, as in IvoryProcDef, is the implementation type.

Methods

callAux :: Name -> Proxy proc -> [Typed Expr] -> impl

Recursive helper call. proc encodes a C procedure type, and this call has two main parts:

• If proc contains arguments, then impl must be a function type causing this whole call to expect an Ivory value that was passed in to apply to the C procedure. In this case, proc is reduced by removing the first C argument from the type itself, and the argument to impl is accumulated onto the list of typed expressions.
• If proc contains no arguments, then this returns the Ivory effect which calls the function with all the arguments in the list applied to it, and captures and returns the result.

Instances

(IvoryVar a, IvoryVar r, IvoryCall ((:->) * args r) eff impl) => IvoryCall ((:->) * ((:) * a args) r) eff (a -> impl)

IvoryVar r => IvoryCall ((:->) * ([] *) r) eff (Ivory eff r)

call_ :: forall proc eff impl. IvoryCall_ proc eff impl => Def proc -> impl

Direct calls, ignoring the result.

indirect_ :: forall proc eff impl. IvoryCall_ proc eff impl => ProcPtr proc -> impl

Indirect calls, ignoring the result.

class IvoryCall_ proc eff impl | proc eff -> impl, impl -> eff where

Typeclass for something callable in Ivory without a return value needed. This is otherwise identical to IvoryCall.

Methods

callAux_ :: Name -> Proxy proc -> [Typed Expr] -> impl

Instances

(IvoryVar a, IvoryType r, IvoryCall_ ((:->) * args r) eff impl) => IvoryCall_ ((:->) * ((:) * a args) r) eff (a -> impl)

IvoryType r => IvoryCall_ ((:->) * ([] *) r) eff (Ivory eff ())

ret :: (GetReturn eff ~ Returns r, IvoryVar r) => r -> Ivory eff ()

Primitive return from function.

retVoid :: (GetReturn eff ~ Returns ()) => Ivory eff ()

Primitive void return from function.