How to make function call without bracket (, )

[rawhuul]

Hi, I am making a DSL where I want to call function without putting arguments in brackets, like foo 1, bar 1, foo bar 1,foo bar baz 1 which will de-sugar to foo(1), bar(1), foo(bar(1)), foo(bar(baz(1)))

[schungx]

That would be difficult if you need it to work for any function name. For fixed function names you can probably define a custom syntax.

Or use a custom prefix like #foo 1, $bar 1 etc.

[rawhuul]

I searched the documentation but it isn't mentioned there, How can I achieve this?

[schungx]

Check out the section on custom syntax in the Book.

[rawhuul]

Hi @schungx, I’ve been working with custom syntax (attached my code below), but I need to make a slight adjustment. I want to be able to call Rhai's print function and some other functions in different scenarios, instead of manually using println!. How can I achieve that?

fn impl_echo(engine: &mut Engine) {
    engine.register_custom_syntax_with_state_raw(
        "echo",
        |symbols, _, _| {
            println!("{symbols:?}");

            match symbols.len() {
                1 => Ok(Some("$expr$".into())),
                2 if symbols[1].as_str() == "$expr$" => {
                    Ok(Some("$$echo".into()))
                }
                _ => Err(LexError::UnexpectedInput(
                    "Too many argument passed".into(),
                )
                .into_err(Position::NONE)),
            }
        },
        false,
        |ctx, input, _| {
            assert_eq!(
                input.last().unwrap().get_string_value().unwrap(),
                "$$echo",
                "This shouldn't have happened"
            );

            let expr = input.get(0).unwrap();

            let value = ctx.eval_expression_tree(expr)?;

            println!("{value}");

            Ok(Dynamic::UNIT)
        },
    );
}

[schungx]

Just call the function print inside your Rust function...

[rawhuul]

Are you referring to Rhai's print function? If so, could you provide a brief example? I tried using it myself, but it didn't work. Also, I have mapped on_print to write to a String. Or are you talking about Rust's native print! macro?

[rawhuul]

I tried this on my end:

engine.register_custom_syntax(
        ["echo", "$expr$"],
        false,
        |ctx, inputs| {
            let expr = ctx.eval_expression_tree(&inputs[0])?;

            let engine = ctx.engine();

            let mut scope = ctx.scope_mut();

            engine.call_fn::<()>(
                &mut scope,
                &AST::default(),
                "print",
                (expr,),
            )?;

            // println!("{expr}");

            Ok(Dynamic::UNIT)
        },
    )?;

[rawhuul]

Hey, I got it working with the code below, but I'm curious if there's a better or more optimal way to achieve the same result.

fn register_echo_keyword(engine: &mut Engine) -> Result<(), EvalAltResult> {
    engine.register_custom_syntax(
        ["echo", "$expr$"],
        false,
        |ctx, inputs| {
            let expr = ctx.eval_expression_tree(&inputs[0])?;

            let engine = ctx.engine();

            let global_state = engine.new_global_runtime_state();

            let nc = NativeCallContext::new_with_all_fields(
                engine,
                "print",
                None,
                &global_state,
                Position::NONE,
            );

            nc.call_fn::<()>("print", (expr,))?;

            Ok(Dynamic::UNIT)
        },
    )?;

    Ok(())
}

[schungx]

I suppose you can just use ctx.global_runtime_state()...

Other thank that, it looks sound to me...

Maybe I should add the call_fn, call_native_fn etc. methods to EvalContext also...

[rawhuul]

Maybe I should add the call_fn, call_native_fn etc. methods to EvalContext also...

Yes, it would be much helpful.