Method call operator?

[renlite]

The operator "->" before a returning type in a procedure definition helps IMO to improve the readability of coding.

My question is: Could the operater "->" be replaced by "." for method calls? This would make the operator "->" unique for procedure defs.

I know Onyx is a data-oriented language, but if somebody prefers to include procedures to structs or unions, I think in this case the programer would like to use an oo-style call of methods.

self or &self (me or this) makes the coding clearer to read and understand.

use core

Foo :: struct {
    name: str;

    say_name :: (self) {
        core.printf("My name is {}\n", self.name);
    }

    // Static method 
    say_some_name :: (name: str) {
        core.printf("My name is {}\n",name);
    }

    // Entirely redundant method, but illustrates passing by pointer.
    set_name :: (&self, name: str) {
        // f can be modified here because it is passed by pointer.
        self.name = name;
    }
}

main :: () {
    // Create a zero-initialized Foo.
    foo: Foo;

    // Call the set_name method
    foo.set_name("Jane");
    foo.set_name(&foo, "Jane")  // ***NOT ALLOWED

    foo.say_name();
    foo.say_name(foo)  // ***NOT ALLOWED

    Foo.say_some_name("Jane");  // static procedure/method
    foo.say_some_name("Jane");  // ***NOT ALLOWED

}

[brendanfh]

Hello! Thank you for the suggestion!

Here are my initial thoughts.

For the case you stated above, I can agree that it is arguably cleaner and more cohesive with other OO-styled languages.

My hesitation is when it comes to storing procedure pointer/references on structures. If that procedure pointer does not take a self argument, then what should the semantics of that be? The Iterator struct is a good example of this. It has multiple function pointers that do not take self, but instead another data member that is stored on the structure.

Iterator :: struct (T: type_expr) {
    data: rawptr
    next: (rawptr) -> ? T
    // ...
}

If you tried to use the syntax you listed, I think there would be confusion as to what is/should be passed to the function.

foo: Iterator(i32)
foo.next(foo.data) // Should this pass &foo first? or is it different because there is no `self` on the procedure reference?

To keep things simple I took Lua's approach to this, which is to have a separate operator for calling a method. That way it is clear to the end user how arguments are being passed. OO in Lua for reference. Note, Onyx can't use the : operator because that is already used for other things in Onyx, so I took the C/PHP inspiration of ->.

[renlite]

Hello, thank you for the explanation.
For the Iterator example I am thinking about:

Iterator :: struct (T: type_expr) {
    data: rawptr
    next: (self) -> ? T
    data: rawptr = self.data
    // ...
    next_other: (self, other: Iterator(T)) -> ? T
    // ...
    next_stat: (rawptr) -> ? T
    // ...
}

// Calling the procs:
foo: Iterator(i32)
bar: Iterator(i32)
Iter32 :: Iterator(i32)  //Alias

res1 := foo.next()
res2 := foo.next_other(bar)
res3 := Iterator(i32).next(foo.data)
res3 := foo::next(foo.data)  //? maybe not good idea, not one way to call
res3 := Iterator(i32).next(bar.data)
res4 := Iter32.next(foo.data)

I like the syntax and the design of Onyx. Maybe it's clearer to use -> for method calls but with . it seems to be more consistent and no mix between definition and usage