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 call syntax
Haskell omits parentheses and commas in function calls, i.e.
a b c d
Is equivalent to Java coded a(b,c,d). Further expamples, inspired by schoolofhaskell.com :
Haskell 
Java 
Comment 
a b c d 
a(b,c,d) 

f 1 
f1 
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 commaseparated arguments results in a call with one argument that is a tuple. 
Scala3
The following table contains examples inspired by a discussion on stackoverflow.
TBD: What does call syntax in Scala3 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
Examples inspired by manual
at nimlang.org.
Nim 
Java 
Comment 
m(o, a) 
o.m(a) 
Not objectoriented 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 
Fuzion call syntax
The following tables show what is currently considered for Fuzion:
Call with and without parentheses
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. 
Examples
Binding strength of calls and prefix/postfix operators:
Fuzion 
Haskell 
Java 
Comment 
f 1 
f (1) 
f(1) 
Rakustyle: 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 oparator, so this is equivalent to f.infix (1). 
f1 
f  1 
f  1 
Without any spaces, we also get an infix oparator, so this is equivalent to f.infix (1). 
f x1 
f (x1) 
f(x1) 
Extended Rakustyle: infix operators without space bind stronger than calls! 
f x  1 
f x  1 
f(x)  1 
Extended Rakustyle: infix operators with space bind weaker than calls! 
f x 1 
f x (1) 
f(x, 1) 
Rakustyle: prefix operators without space bind stronger than calls! 
f x 1 
f (x) 1 
f(x.postFixMinus(), 1) 
Rakustyle: postfix operators without space bind stronger than
calls, so this is equivalent to f(x.postfix , 1). 
Examples
Calls with parentheses:
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 
Examples
Binding strength of calls and infix operators:
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). 
Examples
Function Composition
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. 
Examples
Currying
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. 
Examples
Tuples as 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 doubleparentheses 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. 
Examples
Objectoriented style calls
Fuzion 
Haskell 
Java 
Comment 
obj.m x 
 
obj.m(x) 
Objectoriented 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) 
Scalalike 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) 
Nimstyle call syntax for objectoriented 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 unittype feature trigo
and then either use trigo.sin α or to inherit trigo to
make sin visible such that a call sin α is possible. 
Examples
Type parameters
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>() 
Examples
Dollar / left pipe / applyto operator in calls
Haskell provides the $
operator, F# has <
to avoid parentheses in chained calls. Do we need this is 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? 