Struct Module 

pub struct Module<State>
where
    State: Clone + Send + Sync + 'static,
{
    pub name: String,
    /* private fields */
}

Fields

name: String

Implementations

impl<State> Module<State>

where State: Clone + Send + Sync + 'static,

pub fn new(name: impl Into<String>) -> Module<State>

pub fn add_declaration( &mut self, declaration: impl Into<String>, ) -> Result<(), EngineError>

Add raw Rex declarations to this module (for example pub type ...).

Declarations are concatenated into the module source exactly as provided.

pub fn add_adt_decl(&mut self, adt: AdtDecl) -> Result<(), EngineError>

Add an ADT declaration to this module.

pub fn add_adt_decls_from_types( &mut self, engine: &mut Engine<State>, types: Vec<Type>, ) -> Result<(), EngineError>

Collect user ADTs referenced by types, convert each to an AdtDecl, and add the declarations to this module.

This deduplicates discovered ADTs across all inputs. If conflicting ADT definitions are found (same name, different constructor definition), this returns an EngineError describing every conflict.

Examples

use rex_engine::{Engine, Module};
use rexlang_typesystem::{BuiltinTypeId, Type};

let mut engine = Engine::with_prelude(()).unwrap();
let mut module = Module::new("acme.types");
let types = vec![
    Type::app(Type::user_con("Foo", 1), Type::builtin(BuiltinTypeId::I32)),
    Type::user_con("Bar", 0),
];

module.add_adt_decls_from_types(&mut engine, types).unwrap();

pub fn inject_rex_adt<T>( &mut self, engine: &mut Engine<State>, ) -> Result<(), EngineError>

where T: RexAdt,

Build and add a Rust-backed ADT declaration into this module.

pub fn add_export(&mut self, export: Export<State>)

pub fn export<Sig, H>( &mut self, name: impl Into<String>, handler: H, ) -> Result<(), EngineError>

where H: Handler<State, Sig>,

pub fn export_async<Sig, H>( &mut self, name: impl Into<String>, handler: H, ) -> Result<(), EngineError>

where H: AsyncHandler<State, Sig>,

pub fn export_native<F>( &mut self, name: impl Into<String>, scheme: Scheme, arity: usize, handler: F, ) -> Result<(), EngineError>

where F: for<'a> Fn(&'a Engine<State>, &'a Type, &'a [Pointer]) -> Result<Pointer, EngineError> + Send + Sync + 'static,

pub fn export_native_async<F>( &mut self, name: impl Into<String>, scheme: Scheme, arity: usize, handler: F, ) -> Result<(), EngineError>

where F: for<'a> Fn(&'a Engine<State>, Type, Vec<Pointer>) -> Pin<Box<dyn Future<Output = Result<Pointer, EngineError>> + Send + 'a>> + Send + Sync + 'static,