# Parentheses

Parentheses typically have three purposes in programming languages:

- in expressions, parentheses are used to override operator precedence, e.g.,
a * (b + c)

- in calls, parentheses are used to enclose actual arguments, e.g.,
f(x, g(h(y, z)))

- in function declarations, parentheses are used to enclose formal argument, e.g.,
square(x f64) => x*x

- defining tuples, e.g.,
(x, y)

## Parentheses in Operator Expression

### Parentheses for Operator Precedence

Just as one would expect, parentheses in Fuzion can override default operator precedence in Fuzion. This can be particularly important since operators could be prefix, infix, or postfix operators:

f (s string) is prefix + => f("<" + s + ">") postfix + => f("[" + s + "]") infix + (g f) => f("(" + s + "," + g.s + ")") redef asString => s.asString say "(1): " + (+ f("a") + + + f("b") +) say "(2): " + ((+ f("a")) + ((+ (+ (f("b") +))))) say "(3): " + ((+ ((f("a") +) +) + f("b")) +)

Here, the expression passed to `say`

marked with `(1)`

will produce the same output as the one marked with `(2)`

, while the
parentheses used in `(3)`

results in completely different output:

(1): (<a>,<<[b]>>) (2): (<a>,<<[b]>>) (3): [(<[[a]]>,b)]

### Parentheses for Multi-line Expressions

Expressions in Fuzion are restricted to a single code line. For expressions to be able to extend over several source code lines, they must be enclosed in parentheses:

x := 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10

Will cause a compile time exception since this will be parsed as two statements, first

x := 1 + 2 + 3 + 4 + 5 +

followed by

6 + 7 + 8 + 9 + 10

Resulting in two errors: First, the second lines indentation is invalid, and
also thare is no `postfix +`

operator that could be applied
to `5`

at the end of the first line.

To compile these two lines, we can use parentheses as follows:

x := (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10)

## Parentheses in Calls

### Function call chaining

Parentheses in calls are optional in Fuzion as long as the innermost call takes the last argument, e.g,, the calls in

f(x, g(h(y, z)))

Are equivalent to

f x, g h y, z

However, if an inner call takes only part of the following argument such as the call to `h`

in

f(x, g(h(y)), z)

requires parentheses as follows

f x, g h(y), z

For the parser to distinguish this from the previous code.

### Function calls and operators

Mixing operators, in particular prefix operators with calls causes problems for the parser if parentheses are left out. In this code:

a := f(-x)

Leaving out the parentheses results in

a := f -x

Which can be parsed as an infix minus operator applied to `f`

and `x`

. So we need to put parentheses in a call if the first
parameter starts with a prefix operator, which is somewhat ugly.

Alternatively, we can change the parser to syntactically differentiate infix
and prefix operators as follows, similar to what is done in XL:
An operator with white space (including comments) to its left and no white space
(nor comments) to its right would be parsed as an infix operator. Consequently,
the following code would all compile as a call to `f`

with
argument `-x`

:

# all of the following lines will call f with argument -x a := f(-x) a := f(- x) a := f( - x) a := f -x a := f /* first and only argument: */ -x a := f/* first and only argument: */-x

While the following code would be parsed as `infix -`

applied
to `f`

and `x`

:

# all of the following lines will call the infix operator '-' as in f.infix -(x) a := f-x a := f - x a := f- x a := f-/* <- this is an infix minus */x

Using white space to change the semantics of a program causes a lot of dispute. However, if you look at these examples, interpreting the white space as suggested here results in the least surprise for human readers, so the danger of introducing errors can be expected to be very low.

There are other situations where white space would change the semantics as
well, examples are the differences between `x ++ y`

and ```
x +
+
```

, where the first uses an infix operator `++`

and the second
uses two operators, a postfix `+`

and an infix `+`

.
Similarly, `foobar`

is clearly sementically different from ```
foo
bar
```

.

## Parentheses in Feature Declarations

TBW

## Parentheses for tuples

TBW