Struct Library 

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

Fields

name: String

Implementations

impl<State> Library<State>

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

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

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

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

Declarations are concatenated into the library source exactly as provided.

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

Add an ADT declaration to this library.

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 library.

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, Library};
use rexlang_typesystem::{BuiltinTypeId, Type};

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

library.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 library.

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>) -> NativeFuture<'a> + Send + Sync + 'static,