=> vs. := about fuzion

[fridis]

I am also searching for a more consistent syntax here. Some thoughts on := can be found in Fuzion design page on assignments.

[hkienle]

Thanks for the pointer.

[Achim63]

I'd prefer -> or =>, as modern programming fonts have nice ligatures for those (e.g. Cascadia Code or Fira Code), at least in Visual Studio Code, Sublime, BBedit and in multiple terminals (so that they are also used in the shell versions of vim, emacs etc.). Here's a compatibility list which might even give more ideas: https://github.com/tonsky/FiraCode#terminal-compatibility-list

[fridis]

Thanks for the reference to FiraCode. Making the code look good in current editors is important.

My current ideas go a bit further. First, I would like to make the ( ) around the arguments in feature declarations optional. But then I probably need something to separate the result type from the arguments, i.e., instead of

add (a, b i32) i32 is a + b

one would write

add a, b i32 -> i32 is a + b

where -> serves as a separator between the arguments and the result type.

Then, I would like to use := for all assignments to fields, independent of type inference. So a field declaration with an explicit type would by

sum -> i32 := a + b

and with an inferred type, it would be

sum := a + b

Then, the syntax for a routine with type inference for the result could use '=>' as before, so the example from above

add a, b i32 -> i32 is a + b

could be written as

add a, b i32 => a + b

using type inference.

This is only slightly inconsistent: for fields, := is used in both cases, while for routines, is and => are used. I need this distinction since

add x, y i32 is

declares a constructor for a new product type add with elements x and y. An alternative syntax for a routine with explicit result type would be

add a, b i32 -> i32 => a + b

which would be more consistent, but for some reason I prefer using is here.

In summary, this might be the syntax:

sum -> i32 := a + b
sum := a + b
add a, b i32 -> i32 is a + b
add a, b i32 => a + b

or, using unicode chars as ligatures

sum → i32 ≔ a + b
sum ≔ a + b
add a, b i32 → i32 is a + b
add a, b i32 ⇒ a + b

Maybe, in a next step, the -> could be removed or made optional as well, resulting in

sum i32 := a + b
sum := a + b
add a, b i32 i32 is a + b
add a, b i32 => a + b

but this syntax might cause problems in the parser since it becomes more difficult to distinguish a feature declaration from a call. Also, this seems a bit hard for humans to parse as well, in particular for add with explicit result type.

[fridis]

Closing this, the syntax of Fuzion has stabalized a bit by now:

• := is used to declare a field and assign a value. It should no longer be used to mutate a value (even though the grammar still permits that (set x := y) and it happens in the base lib)
• => is used to declare a routine with result type determined by type inference and also in a match-case.
• -> is used in lambdas x -> f x
• <- is used to assign a new value to a mutable field.
• there is no need for a separator before a feature result type (f(x i32) i32 is x*x, not f(x i32) -> i32 is x*x.