IDEA: Is api really easy?

[sagudev]

If I understand correctly you call rust function from JS like:
esses.invoke_rust_op_sync("print", "this will be printed")
is it possible to invoke it like:
print("this will be printed")

Writing rust functions for JS is still pretty hard (not hard as writing it directly for mozjs):

fn reg_op(rt: &EsRuntimeWrapper) {
    rt.register_op(
        "my_rusty_op",
        Arc::new(|_rt, args: Vec<EsValueFacade>| {
            let a = args.get(0).unwrap().get_i32();
            let b = args.get(1).unwrap().get_i32();
            Ok(EsValueFacade::new_i32(a * b))
        }),
    );
}

My idea is that adding rusty code to JS should be as close as writing normal rust code and than just telling es_runtime to use that function (preferably even without special types, using Rusts types).

[andrieshiemstra]

You're right, register_op was one of the first things i got working, a lot has changed since then. I'll look into changing this in this issue.

Thanks for the tip!

[sagudev]

What about esses.invoke_rust_op_sync?

[andrieshiemstra]

well on the rust side i'd like to refactor it to work like this

rt.add_function("my_function", |args: Vec<EsValueFacade>| {
    EsValueFacade::new_str("a value".to_string())
});
// or
rt.add_function("com.my_org.MyObj.my_function", |args: Vec<EsValueFacade>| {
    EsValueFacade::new_str("a value".to_string())
});

this will add 2 native functions to the root or the package in the script engine
e.g. (or should we add sync/async optionally with an extra boolean param?)

• my_function -> Promise
• my_functionSync -> Value

so in script you can do:

let aPromise = my_function(1, 2, 3);
// or
let aValue  = my_functionSync(1, 2, 3);

implementing this will be quite easy with the current Utils i have

the closures can be added to a HashMap by name and that name will also be set as a permanent property to the JSFunction objects created in the scope

The JSFunction will point to a native method which will check the property of the callee object (which will be the JSFunction) and so we can get the closures from the map and invoke them...

[andrieshiemstra]

this example:

rt.add_function("com.my_org.MyObj.my_function", |args: Vec<EsValueFacade>| {
    EsValueFacade::new_str("a value".to_string())
});

could also be done with a Proxy, but currently i'm unsure how to proceed with the 'Easy' variant EsProxy... the problem was that i don't really want the 'Easy' code to run in the worker thread of the engine but that would mean you can only have methods that return a Promise... i'm tempted to place some responsibility on the 'Easy' dev afterall and just document that you need to be carefull about running long running code in sync methods...

[andrieshiemstra]

one last note: about the sync/async variants

i'd really like async functions to be the "normal" way to implement functions.

We could also implement add_function to simply add one function and put the responsibility of returning a Promise on the devs shoulders but i'm afraid that may lead to people just doing everything sync... what do you think?

[sagudev]

What about using procedural macros. Something like servo is using just without webidl and codegen. It make sense that struct is then JS object and methods are its functions. And with procedural macros I think we can achieve to return a Promise even if original function is meant to be sync.

For choosing between async and sync funcion it could be like:

let aPromise = sync.my_function(1, 2, 3);
// or
let aValue  = async.my_function(1, 2, 3);
// or import function to global (you can import sync or async function to global)
import { my_function } from async
let aPromise = my_function(1, 2, 3);

[andrieshiemstra]

Or maybe turn that around?

let aPromise = my_function(1, 2, 3);
let aValue = my_function.sync(1, 2, 3);

Then again it would make adding simple sync util methods complex...

[andrieshiemstra]

Wrong button 😀

[andrieshiemstra]

i'm tempted toward just having two functions in rust

rt.add_function("my_function", |args: Vec<EsValueFacade>| {
    EsValueFacade::new_str("a value".to_string())
});
// and
rt.add_sync_function("my_other_function", |args: Vec<EsValueFacade>| {
    EsValueFacade::new_str("a value".to_string())
});

in which case the "normal" function returns a promise and you need to use the sync rust variant to add a sync function to JS

let aPromise = my_function(1, 2, 3);
let aValue = my_other_function(1, 2, 3);

Naming them so they tell the user what they do is up to common sense of the dev...

[andrieshiemstra]

i'd also like to figure out how to use generics and/or traits so you could just write

rt.add_function("my_function", |args: Vec<EsValueFacade>| {
    "a value" // or 123 // or true
});

and do the conversion to EsValueFacade behind the scenes

[sagudev]

More like:

let aPromise = my_function(1, 2, 3);
let aValue = sync.my_function(1, 2, 3);

and as for rust functions I would make even input args a rust type, maybe something like:

#[jsfn]
pub fn print(s: String) {
      println!("rust said: {}", s)
}

and there is also rjs. Which is very similar to es_runtime. There is an interesting way of handling functions.

[andrieshiemstra]

More like:

let aPromise = my_function(1, 2, 3);
let aValue = sync.my_function(1, 2, 3);

would that not just enable people to run ops sync while they realy should not be doint that.

if the js dev wants easier notation he could just use await in an async function

async function do_something() {
    let aValue = await my_function(1, 2, 3);
}

and as for rust functions I would make even input args a rust type, maybe something like:

#[jsfn]
pub fn print(s: String) {
      println!("rust said: {}", s)
}

although i like the shortness i dislike the lack of controll as in which runtime/module/scope do i add this method to...

i'd like to stick to this for now also because i'm not that handy with macro's yet

rt.add_function("my_function", |args: Vec<EsValueFacade>| {
    "a value" // or 123 // or true
});

and there is also rjs. Which is very similar to es_runtime. There is an interesting way of handling functions.

ooh, lot of ideas to be found there :) .. i'll check it out