Calls

Parentheses in calls are optional. How about commas to separate actual arguments and dots to separate the call target from the called feature name?

Other Languages

Haskell omits parentheses and commas in function calls, i.e.

  a b c d

is equivalent to the Java code a(b,c,d). Further examples, inspired by schoolofhaskell.com :

Haskell	Java	Comment
a b c d	a(b,c,d)
f -1	f-1	CAVEAT: This is not a call, but an infix operation!
f (-1)	f(-1)	Parentheses around argument make this a call.
(f a b)	f(a,b)	Parentheses go around a call
a b * c d	a(b)*c(d)	Call has highest precedence
a (b * c) d	a(b*c, d)	Parentheses are needed around infix/prefix/postfix expressions given as call arguments
f g x	f(g, x)	Even if f, g are both functions, g is not called here, but passed as argument to f. Function call binds to the left.
f (g x)	f(g(x))	Parentheses are required to pass the result of applying `g` to `x` to `f`.
f $ g $ x	f(g(x))	Alternatively, `$` can be used as a function call operator that binds to the right.
(f . g) x	int fg(int y) { return f(g(y)); } fg(x);	Function composition in Haskell is done using a dot.
f x y = x + y*y g = f 3 g 4	int f(int x, y) { return x + y*y; } int g(int y) { return f(3, y); } g(4);	Currying: Applying only a part of the arguments to a function results in a function that expects the remaining arguments.
f (a, b)	record Tuple(int v, int w) { } f(new Tuple(a, b))	Classical call syntax in Haskell with comma-separated arguments results in a call with one argument that is a tuple.

The following table contains examples inspired by a discussion on stackoverflow.

TBD: What does call syntax in Scala-3 look like? Any changes?

Scala	Java	Comment
o.m(a)	o.m(a)	Dot notation like in Java.
o m (a)	o.m(a)	Operator notation.
o m a	o.m(a)	Operator notation with single argument does not require parentheses.
o m	o.m()	Operator notation without arguments does not require parentheses.
a m: o	o.m:(a)	Operator notation inverts target and arguments if called method ends in `:`.

Nim	Java	Comment
m(o, a)	o.m(a)	Not object-oriented style notation.
o.m(a)	o.m(a)	Dot notation like in Java.
o.m	o.m()	Parentheses are optional for dot notation with no arguments

The following tables show what is currently considered for Fuzion:

Fuzion	Haskell	Java	Comment
a(b,c,d)	a b c d	a(b,c,d)	Fuzion should support classic call syntax.
a b c d	a b c d	a(b,c,d)	Parentheses and commas should be optional.
a b (c d)	a b (c d)	a(b,c(d))	Parentheses group calls and arguments.
a (b c) d	a (b c) d	a(b(c),d)	Parentheses group calls and arguments.

Fuzion	Haskell	Java	Comment
f -1	f (-1)	f(-1)	Raku-style: infix or postfix operators bind stronger if there is no space between the operator and its operand.
f - 1	f - 1	f - 1	With spaces, we get an infix operator, so this is equivalent to `f.infix -(1)`.
f-1	f - 1	f - 1	Without any spaces, we also get an infix operator, so this is equivalent to `f.infix -(1)`.
f x-1	f (x-1)	f(x-1)	Extended Raku-style: infix operators without space bind stronger than calls!
f x - 1	f x - 1	f(x) - 1	Extended Raku-style: infix operators with space bind weaker than calls!
f x -1	f x (-1)	f(x, -1)	Raku-style: prefix operators without space bind stronger than calls!
f x- 1	f (x-) 1	f(x.postFixMinus(), 1)	Raku-style: postfix operators without space bind stronger than calls, so this is equivalent to `f(x.postfix -, 1)`.

Fuzion	Haskell	Java	Comment
f(a b c)	f (a b c)	f(a(b, c))	Parentheses may go around all arguments and commas can be omitted, turning this into `f(a(b, c))`.
f(a, b, c)	(f a b c)	f(a, b, c)	Parentheses may go around all arguments, requiring commas to avoid turning argument list into a call. So this is equivalent to `f a b c`.
(f a b c)	(f a b c)	f(a,b,c)	Parentheses may go around a call

Fuzion	Haskell	Java	Comment
a b * c d	a b * c d	a(b)*c(d)	Call has highest precedence, so this is equivalent to `a(b) * c(d)`.
a b*c d	a (b * c) d	a(b*c, d)	infix operator without spaces has higher precedence than call. so this is equivalent to `a(b*c,d)`.

Fuzion	Haskell	Java	Comment
f g x	f g x	f(g, x)	Even if f, g are both functions, g is not called here, but passed as argument to f. Function call binds to the left.
f(g x)	f (g x)	f(g(x))	Parentheses are required to pass the result of applying `g` to `x` to `f`.
NYI: Compose operator	(f . g) x)	int fg(int y) { return f(g(y)); } fg(x);	Function composition via a dedicated operator is currently not supported. Need compelling use cases to justify this, could be realized with syntactic sugar.

Fuzion	Haskell	Java	Comment
f(i32 x, y) => x + y*y g => f 3 # NYI! Currying g 4	f x y = x + y*y g = f 3 g 4	int f(int x, y) { return x + y*y; } int g(int y) { return f(3, y); } g(4);	NYI: Currying: Applying only a part of the arguments to a function results in a function that expects the remaining arguments.

Fuzion	Haskell	Java	Comment
f((a, b))	f (a, b)	record Tuple(int v, int w) { } f(new Tuple(a, b))	Passing a tuple in Fuzion requires double-parentheses to disambiguate passing a tuple from a call using parentheses.
f (a, b)	f (a, b)	record Tuple(int v, int w) { } f(new Tuple(a, b))	Separating the argument from the name of the called feature turns the argument into a tuple.

Fuzion	Haskell	Java	Comment
obj.m x	--	obj.m(x)	Object-oriented dot notation for a call. Here, the scope to lookup `m` is different, `m` is searched for in the visible features of the static type of `obj` only.
obj m x # not supported! useful?	--	obj.m(x)	Scala-like operator notation for a call. This would result in an ambiguity if `m` exists both in the local scope and in the static type of `obj`. Which `m` should be taken in this case?
m obj x # not supported! useful?	--	obj.m(x)	Nim-style call syntax for object-oriented calls. If `f64` declares `sin`, this would permit code like `sin α` for a `f64` value `α` instead of `α.sin`. Does this justify extending the call syntax? An alternative with the same effect would be to declare `sin` within a different unit-type feature `trigo` and then either use `trigo.sin α` or to inherit `trigo` to make `sin` visible such that a call `sin α` is possible.

Fuzion	Haskell	Java	Comment
myMap i32 String	myMap i32 String	myMap<i32,String>()	Fuzion syntax for type parameters in a call is the same as for value parameters, i.e., using either spaces or `(` `,` `)` to separate arguments.
myMap(i32, String)	myMap i32 String	myMap<i32,String>()

Haskell provides the $ operator, F# has <| to avoid parentheses in chained calls. Do we need this in Fuzion?

Fuzion	Haskell	F#	Comment
draw (point (a (b x) (a (b y))))	draw $ point (a $ b x) (a $ b y)	draw <\| point (a <\| b x) (a <\| b y)	Which of these is best?