fn add(mut args: Vec<LazyVal>, handle: &Executable) -> VResult {
    // load_args! macro is used to extract the arguments from the args vector. This uses
    // .into() to convert the Val into the appropriate type. For example an int list, which is written
    // as  Dom(List(Vec<Dom(Int)>)), can be .into()'d into a Vec<i32> or a Vec<Val> or a Val.
    load_args!(handle, args, x:i32, y:i32); 
    // ok() is a convenience function that does Ok(v.into()) for you. It relies on your internal primitive types having a one
    // to one mapping to Val variants like `Int <-> i32`. For any domain, the forward mapping `Int -> i32` is guaranteed, however
    // depending on your implementation the reverse mapping `i32 -> Int` may not be. If that's the case you can manually construct
    // the Val from the primitive type like Ok(Dom(Int(v))) for example. Alternatively you can get the .into() property by wrapping
    // all your primitive types eg Int1 = struct(i32) and Int2 = struct(i32) etc for the various types that are i32 under the hood.
    ok(x+y)
}
// *** DSL FUNCTIONS ***
// See comments throughout pointing out useful aspects
DSL FUNCTIONS
See comments throughout pointing out useful aspects
DSL FUNCTIONS See comments throughout pointing out useful aspects
fn add(mut args: Vec<LazyVal>, handle: &Executable) -> VResult {
    // load_args! macro is used to extract the arguments from the args vector. This uses
    // .into() to convert the Val into the appropriate type. For example an int list, which is written
    // as  Dom(List(Vec<Dom(Int)>)), can be .into()'d into a Vec<i32> or a Vec<Val> or a Val.
    load_args!(handle, args, x:i32, y:i32); 
    // ok() is a convenience function that does Ok(v.into()) for you. It relies on your internal primitive types having a one
    // to one mapping to Val variants like `Int <-> i32`. For any domain, the forward mapping `Int -> i32` is guaranteed, however
    // depending on your implementation the reverse mapping `i32 -> Int` may not be. If that's the case you can manually construct
    // the Val from the primitive type like Ok(Dom(Int(v))) for example. Alternatively you can get the .into() property by wrapping
    // all your primitive types eg Int1 = struct(i32) and Int2 = struct(i32) etc for the various types that are i32 under the hood.
    ok(x+y)
}
fn add ( mut args : Vec < LazyVal > , handle : & Executable ) -> VResult { // load_args! macro is used to extract the arguments from the args vector. This uses // .into() to convert the Val into the appropriate type. For example an int list, which is written // as  Dom(List(Vec<Dom(Int)>)), can be .into()'d into a Vec<i32> or a Vec<Val> or a Val. load_args ! ( handle args x i32 y i32 ) ; // ok() is a convenience function that does Ok(v.into()) for you. It relies on your internal primitive types having a one // to one mapping to Val variants like `Int <-> i32`. For any domain, the forward mapping `Int -> i32` is guaranteed, however // depending on your implementation the reverse mapping `i32 -> Int` may not be. If that's the case you can manually construct // the Val from the primitive type like Ok(Dom(Int(v))) for example. Alternatively you can get the .into() property by wrapping // all your primitive types eg Int1 = struct(i32) and Int2 = struct(i32) etc for the various types that are i32 under the hood. ok ( x + y ) }
DSL FUNCTIONS
See comments throughout pointing out useful aspects
DSL FUNCTIONS See comments throughout pointing out useful aspects
args
Vec<LazyVal>
handle
&Executable
args
Vec<LazyVal>
handle
&Executable