Uniform Function Call Syntax?

[pyranota]

I really like that rhai has simplified rust syntax. And its clean. But, i think it would be much more interesting and clean to implement Uniform Function Call Syntax, i saw this feature in nim and crystal, and its awesome! Why not to implement it in rhai?

<arg1>.<fnName>(<arg2>, ...)

<fnName> <arg1>, <arg2>, ...

<arg1>.<fnName> <arg2>, <arg3>, ...

[schungx]

The other variants without parentheses would require a line break or a semicolon at the end to terminate... and I think

obj.my_func 123, true;

looks sorta ugly with the ending semicolon...

[pyranota]

Idk, i like that. How about others?

[pyranota]

And I think this is about taste. Someone like me would use it, but someone like you would not.

[schungx]

Fair enough... just confirming: you would accept the need to have an ending semicolon?

It would not be easy to parse, as it would require checking whether an identifier is a valid function. For example, take the following code:

foo;         // should this be the variable 'foo'?  Or 'foo()'?

foo bar, baz;

foo - bar   // should this be foo - bar?  Or foo(-bar)?

When the parser sees foo, it needs to decide whether it is a valid function. That would depend on the Engine, as any function can be dynamically registered at any time... Functions in modules can also be marked "global" so they are available instantly when the module is loaded.

So, at parsing time, it is not immediately certain whether the keyword is a variable or a function.

It is also not easy to judge based on the following token... firstly there may not be one (for a function call with no arguments), second it may be a valid dual unary/binary operator (such as + and -)...

[pyranota]

Yeah, I would accept the need to have an ending semicolon.
Other idea, is to make semicolon optional, it would make Uniform Function Call Syntax pretty for people like you.

How its done in nim:
foo; // error, cant call function like that
foo(); // correct
foo - bar; // foo - bar
foo -bar; // foo(-bar)

[pyranota]

Also it would be awesome to be able to declare functions without parenthesis (if no arguments):

fn my_func {
    todo!();
}

[schungx]

Also it would be awesome to be able to declare functions without parenthesis (if no arguments):

Actually this may be easy to add as the syntax in unambiguous...

[schungx]

Nevertheless, if we can define functions without parentheses, would people expect to be able to call them without parentheses?

fn foo { ... }

let x = foo;    // instead of foo()

[pyranota]

Nevertheless, if we can define functions without parentheses, would people expect to be able to call them without parentheses?

I think they would, but this is not possible to call like this, parser will say that. Its also implemented in nim, and it was there for all this years, and it wasnt the problem.
In my opinion, the main reason why language such Rhai would need this feature, its when you write some functions in rhai without calling it from there. Sort of expected functions for all rhai scripts. In game engines its used often. Just look the example:

// character.rhai
fn init {
  // ..
}
fn ready {
 // .. 
}
fn frame(delta) {
  // ..
}

This functions are expected from every script in the game and called from game engine itself.

---

So what do you think about making semicolon optional? It looks like its easy to implement.

---

I also could try to implement Uniform Function Call Syntax for Rhai. I could make it as an optional feature. But the question is, would you merge Uniform Function Call Syntax into the main branch?

I really like this project tbh, and i want to contribute to it. So, implementing Uniform Function Call Syntax would be nice place to start.

[schungx]

I also could try to implement Uniform Function Call Syntax for Rhai. I could make it as an optional feature. But the question is, would you merge Uniform Function Call Syntax into the main branch?

Certainly. Give it a shot. If it is implemented cleanly without breaking existing code, I don't see why not!