Struct dyon::Dfn

pub struct Dfn {
    pub lts: Vec<Lt>,
    pub tys: Vec<Type>,
    pub ret: Type,
    pub ext: Vec<(Vec<Arc<String>>, Vec<Type>, Type)>,
    pub lazy: &'static [&'static [Lazy]],
}

Stores preloaded function constraints. These are already checked.

Fields

lts: Vec<Lt>

Lifetimes of argument.

tys: Vec<Type>

Argument types of function.

ret: Type

Return type of function.

ext: Vec<(Vec<Arc<String>>, Vec<Type>, Type)>

Extra type information.

Stores type variables, argument types, return type.

lazy: &'static [&'static [Lazy]]

Stores lazy invariants.

Implementations

impl Dfn

pub fn nl(args: Vec<Type>, ret: Type) -> Dfn

Creates a new function signature with no lifetime or refinement.

Examples found in repository

examples/functions.rs (line 22)

fn load_module() -> Option<dyon::Module> {
    use dyon::Type::*;
    use dyon::{error, load, Dfn, Module};

    let mut module = Module::new();
    module.add_str("say_hello", say_hello, Dfn::nl(vec![], Void));
    module.add_str("homer", homer, Dfn::nl(vec![], Any));
    module.add_str("age", age, Dfn::nl(vec![Any], Any));
    module.add_str("mr", mr, Dfn::nl(vec![Str; 2], Str));
    module.add_str("origo", origo, Dfn::nl(vec![], Object));
    module.add_str("id", id, Dfn::nl(vec![], Mat4));

    // Register custom Rust object with an ad-hoc type.
    let ty_custom_object = AdHoc(Arc::new("CustomObject".into()), Box::new(Any));
    module.add_str(
        "custom_object",
        custom_object,
        Dfn::nl(vec![], ty_custom_object.clone()),
    );
    module.add_str(
        "print_custom_object",
        print_custom_object,
        Dfn::nl(vec![ty_custom_object.clone()], Void),
    );
    if error(load("source/functions/loader.dyon", &mut module)) {
        None
    } else {
        Some(module)
    }
}

examples/call.rs (line 14)

fn main() {
    let mut module = Module::new();

    // Add functions to read `a` and `b` from `RustArgs`.
    module.add(
        Arc::new("a_of".into()),
        a_of,
        Dfn::nl(vec![Type::Any], Type::F64),
    );
    module.add(
        Arc::new("b_of".into()),
        b_of,
        Dfn::nl(vec![Type::Any], Type::F64),
    );

    error(load_str(
        "main.dyon",
        Arc::new(
            r#"
        fn add_args(a: f64, b: f64) {
            println("add_args:")
            println(link {a" + "b" = "a + b})
        }

        fn add_obj(obj: {}) {
            println("add_obj:")
            println(link {obj.a" + "obj.b" = "obj.a + obj.b})
        }

        fn add_rust(obj: any) {
            println("add_rust")
            a := a_of(obj)
            b := b_of(obj)
            println(link {a" + "b" = "a + b})
        }

        add(a, b) = a + b

        create_vec(a, b) = (a, b)

        id(obj) = clone(obj)
    "#
            .into(),
        ),
        &mut module,
    ));
    let ref module = Arc::new(module);

    let a = 20.0;
    let b = 30.0;

    // Call with multiple arguments.
    let call = Call::new("add_args").arg(a).arg(b);
    error(call.run(&mut Runtime::new(), module));

    // Call with object.
    let call = Call::new("add_obj").arg(Args { a, b });
    error(call.run(&mut Runtime::new(), module));

    // Call with rust object.
    let call = Call::new("add_rust").rust(RustArgs { a, b });
    error(call.run(&mut Runtime::new(), module));

    // Call function with return value.
    let call = Call::new("add").arg(a).arg(b);
    match call.run_ret::<f64>(&mut Runtime::new(), module) {
        Ok(answer) => {
            println!("{}", answer);
        }
        Err(err) => {
            error(Err(err));
        }
    }

    // Call function that returns vec4.
    let call = Call::new("create_vec").arg(a).arg(b);
    match call.run_vec4::<[f64; 2]>(&mut Runtime::new(), module) {
        Ok(answer) => {
            println!("{:?}", answer);
        }
        Err(err) => {
            error(Err(err));
        }
    }

    // Call function that returns Rust object.
    let call = Call::new("id").rust(RustArgs { a, b });
    match call.run_ret::<RustObject>(&mut Runtime::new(), module) {
        Ok(answer) => {
            println!("{:?}", answer.lock().unwrap().downcast_ref::<RustArgs>());
        }
        Err(err) => {
            error(Err(err));
        }
    }
}

pub fn new(f: &Function) -> Dfn

Creates new function signature from an AST function.

pub fn returns(&self) -> bool

Returns true if the function returns something.

Trait Implementations

impl Clone for Dfn

fn clone(&self) -> Dfn

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dfn

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Dfn> for Dfn

fn eq(&self, other: &Dfn) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Dfn