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.

Minimal complete definition

procType

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)

Methods

procType :: Proxy (Proc *) ((* :-> (* ': a) args) r) -> (Type, [Type])

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

Methods

procType :: Proxy (Proc *) ((* :-> [*]) r) -> (Type, [Type])

newtype ProcPtr sig

Procedure pointers

Constructors

ProcPtr

Fields

• getProcPtr :: Name

Instances

ProcType proc => IvoryVar (ProcPtr proc)

Methods

wrapVar :: Var -> ProcPtr proc

unwrapExpr :: ProcPtr proc -> Expr

ProcType proc => IvoryType (ProcPtr proc)

Methods

ivoryType :: Proxy * (ProcPtr proc) -> Type

ProcType proc => IvoryInit (ProcPtr proc)

Methods

ival :: ProcPtr proc -> Init (Stored * (ProcPtr proc))

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

data Def proc

Procedure definitions.

Constructors

DefProc Proc

DefImport Import

Instances

Eq (Def proc)

Methods

(==) :: Def proc -> Def proc -> Bool

(/=) :: Def proc -> Def proc -> Bool

Ord (Def proc)

Methods

compare :: Def proc -> Def proc -> Ordering

(<) :: Def proc -> Def proc -> Bool

(<=) :: Def proc -> Def proc -> Bool

(>) :: Def proc -> Def proc -> Bool

(>=) :: Def proc -> Def proc -> Bool

max :: Def proc -> Def proc -> Def proc

min :: Def proc -> Def proc -> Def proc

Show (Def proc)

Methods

showsPrec :: Int -> Def proc -> ShowS

show :: Def proc -> String

showList :: [Def proc] -> ShowS

ProcType proc => IvoryType (Def proc)

Methods

ivoryType :: Proxy * (Def proc) -> Type

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

Associated Types

type Return (Body :: * -> *) :: *

Methods

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

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

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

Methods

procDef :: Closure -> Proxy (Proc *) ((* :-> [*]) ret) -> Body ret -> ([Var], Definition)

type Return Body

type Return Body = ()

class WrapIvory m where

Minimal complete definition

wrap, unwrap

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

Associated Types

type Return (ImportFrom :: * -> *) :: *

Methods

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

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

WrapIvory Body

Associated Types

type Return (Body :: * -> *) :: *

Methods

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

unwrap :: Body r -> forall s. Ivory (ProcEffects s r) (Return 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.

Minimal complete definition

procDef

Methods

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

Instances

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

Methods

procDef :: Closure -> Proxy (Proc *) ((* :-> [*]) ret) -> ImportFrom ret -> ([Var], Definition)

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

Methods

procDef :: Closure -> Proxy (Proc *) ((* :-> [*]) ret) -> Body ret -> ([Var], Definition)

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

Methods

procDef :: Closure -> Proxy (Proc *) ((* :-> (* ': a) args) ret) -> (a -> k) -> ([Var], Definition)

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

Associated Types

type Return (ImportFrom :: * -> *) :: *

Methods

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

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

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

Methods

procDef :: Closure -> Proxy (Proc *) ((* :-> [*]) ret) -> ImportFrom ret -> ([Var], Definition)

type Return ImportFrom

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.

Minimal complete definition

callAux

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)

Methods

callAux :: Name -> Proxy (Proc *) ((* :-> (* ': a) args) r) -> [Typed Expr] -> a -> impl

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

Methods

callAux :: Name -> Proxy (Proc *) ((* :-> [*]) r) -> [Typed Expr] -> 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.

Minimal complete definition

callAux_

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)

Methods

callAux_ :: Name -> Proxy (Proc *) ((* :-> (* ': a) args) r) -> [Typed Expr] -> a -> impl

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

Methods

callAux_ :: Name -> Proxy (Proc *) ((* :-> [*]) r) -> [Typed Expr] -> 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.