nimforum mirror - Reasoning behind function call syntax in Nim.

undefined (orginal) [2024-02-13T18:20:51+01:00] view original

"Hello, ".echo "world!"

The above code compiles and works. What is the reasoning behind this syntax?

I understood echo "Hello, world!" and the other forms; but what is the reasoning behind allowing the above syntax?

I'm not criticising it; I just wanted to know the reasoning.

doongjohn (orginal) [2024-02-13T18:46:06+01:00] view original

see: https://en.wikipedia.org/w/index.php?title=Uniform_Function_Call_Syntax

basically it allows method style function call without OOP

echo "hello".strip().toUpperAscii()
#           ^       ^
#           └-------┴--> UFCS

namisboss (orginal) [2024-02-13T18:52:42+01:00] view original

The dot is used to let people use object oriented syntax on objects. This site has examples of it in use https://nim-by-example.github.io/types/objects/

Often the space is used to dispatch things. Here's a package that uses this syntax to use a main object to then take functions for multithreading.

https://github.com/Araq/malebolgia

(m.spawn dfs() is used in the example)

demotomohiro (orginal) [2024-02-13T18:53:21+01:00] view original

"Hello, ".echo "world!"

Above syntax uses method call syntax and Command invocation syntax.

Method call syntax allows calling procs in object-oriented way like obj.methodName(args) and chains proc calls like x.foo.bar.baz that is simpler than baz(bar(foo(x))).

didlybom (orginal) [2024-02-13T20:10:21+01:00] view original

Maybe what makes it look odd is a combination of 3 things:

Uniform Function Call Syntax (UFCS) which makes x.echo(...) equivalent to echo(x, ...) (i.e. it lets you treat the first argument of a function as if it were an object that calls a method)

Parens around function arguments are optional (i.e. echo x, ... is equivalent to echo(x, ...)

echo takes a variable number of strings as its arguments. It takes all those strings, concatenates them and echoes the resulting string

If you take all of that into account "Hello, ".echo "world!" is equivalent to echo("Hello, ", "world!")

As for the why of the UFCS and the optional parenthesis, this is my opinion:

UFCS lets you have non object-oriented code "look" object-oriented and let's you concatenate multiple function calls easily and concisely (e.g. func2(func1(x)) becomes x.func1.func2. It also let's you extend "types" defined in libraries with your own "methods" (simply declare a function that takes an object of that type as its first argument, and then call it using UFCS).

The optional parens let you write DSLs easily and combined with UFCS makes it possible to treat function calls as properties (e.g. len(tensor) is equivalent to tensor.len() which is equivalent to tensor.len). If you are familiar with python that would require decorating an object method as a @property).