Separators of operations are parsed inconsistently

[jiribenes]

The following program using a space to separate two operations (both in their definition and implementation) is currently syntactically valid:

interface Foo { def foo(): Int def bar(): Int }
def main() = 
  try { do foo() + do bar() }
  with Foo { def foo() = resume(42) def bar() = resume(100) }

Proof

Inserting semicolons in order to separate the two operations is not allowed: neither in their definition, nor in their implementation.

---

In contrast, if you write:

type Quux { Bar() Baz() }

then you actually must insert a semicolon or a newline to get a successful parse.

[jiribenes]

Related to #287, as the following suggestion would make it a little bit more symmetric:

sequence constructors not with semicolons type B { True(); False() } but type B { case True() case False() }

[jiribenes]

Maybe one more reason why it feels surprising:

def helloWorld() = {
  def foo() = println("hello") def bar() = println("goodbye")
  foo(); bar()
}

does not parse here (requires a newline between the two definitions), but parses fine in the cases outlined above.