Semicolon free grammar and implied line joining

Semicolon free grammar

There is no need to use semicolons in 11l to terminate statements {…}. Statements are always terminated by a newline character if there is no implied line joining occured (see below).

Implied line joining

Instead of clumsy things like Automatic Semicolon Insertion with overly complex rules (which also sometimes works incorrectly {…}) 11l uses in general just 3 simple rules, which are both easy to understand for a human and to implement in a lexical analyser:

Every line of code which ends with any binary operator will be joined with the following/next line of code:
```
I condition1 | // this line will be joined with the following/next line because it ends with a binary operator `|`
  condition2
   some_func()
```

Every line of code which begins with any binary operator will be joined with the previous line of code: {…
Also it is necessary to check that this is not an unary operator:

a = b
++i // plus symbol at the beginning here should not be treated as binary `+` operator

}

some_variable = 2
              + 3 // this line will be joined with the previous line because it begins with a binary operator `+`

And like in Python expressions in parentheses and square brackets can be split over more than one physical line:
[
{…
Perhaps this rule will be abandoned in order to support such code:
```
set_timeout(
            1.0,
            F ()
               alert(‘!’)
            ,
            0
           )
```
Then 3rd rule will be replaced by the following 2 rules:
1. Every line of code which ends with opening/left parenthesis (
  (
  ), square bracket (
  [
  ), or comma (
  ,
  ) will be joined with the following/next line of code.
2. Every line of code which begins with closing/right parenthesis (
  )
  ) or square bracket (
  ]
  ) will be joined with the previous line of code.
}
]
```
some_func( // because there is an unclosed parenthesis all following lines will be joined with this one
   argument1,                                                            \\ until parenthesis is closed
   argument2)
```

Note: dot (

) is not considered as a binary operator because it is also used as a variables' prefix (see Variables' prefixes), and if you want to split member function call over multiple lines, then precede the dot with a backslash:

result = obj.method1()
           \.method2()