doc: proposal new syntax

Blocks are now a litertal 'list of statements'.
This means we use square instead of curly brackets to denote them.

Author: Joel Abrahams

README.md

@@ -79,10 +79,10 @@ def factorial(x: Int) -> Int := match x
     n => n * factorial(n - 1)
 
 def num := input("Compute factorial: ")
-if num.is_digit() then
+if num.is_digit() then [
     def result := factorial(Int(num))
     print("Factorial {num} is: {result}.")
-else
+] else
     print("Input was not an integer.")
 ```
 
@@ -94,10 +94,11 @@ _Note_ One could use [dynamic programming](https://en.wikipedia.org/wiki/Dynamic
 ```mamba
 def factorial(x: Int) -> Int := match x
     0 => 1
-    n =>
-        def ans := 1
-        for i in 1 ..= n do ans := ans * i
-        ans
+    n => [
+      def ans := 1
+      for i in 1 ..= n do ans := ans * i
+      ans
+    ]
 ```
 
 ### 📋 Types, Classes, and Mutability
@@ -120,9 +121,10 @@ class MyServer(def ip_address: IPv4Address)
     def last_sent(fin self) -> Str ! ServerError :=
         self._last_message
 
-    def connect(self) :=
+    def connect(self) := [
         self.is_connected := True
         print(always_the_same_message)
+    ]
 
     def send(self, message: Str) ! ServerError :=
         if self.is_connected then
@@ -271,11 +273,12 @@ Immutable variables and pure functions make it easier to write declarative progr
 def fin taylor := 7
 
 # the sin function is pure, its output depends solely on the input
-def pure sin(x: Int) :=
+def pure sin(x: Int) := [
     def ans := x
     for i in 1 ..= taylor .. 2 do
         ans := ans + (x ^ (i + 2)) / (factorial (i + 2))
     ans
+]
 ```
 
 ### ⚠ Error handling
@@ -311,12 +314,14 @@ This is shown below:
 
 ```mamba
 def a := function_may_throw_err()
-    err: MyErr :=
+    err: MyErr => [
         print("We have a problem: {err.message}.")
         return  # we return, halting execution
-    err: MyOtherErr :=
+    ]
+    err: MyOtherErr => [
         print("We have another problem: {err.message}.")
         0  # ... or we assign default value 0 to a
+    ]
 
 print("a has value {a}.")
 ```

docs/spec/characters.md

@@ -15,7 +15,9 @@ Symbol | Use
 `{` | Denote start of set, set constructor, or map
 `}` | Denote end of set, set constructor, or map
 `[` | Denote start of list, or opening bracket of generics of a class
+    | Also denotes the start of a list of statements and/or expressions
 `]` | Denote end of list, or closing bracket of generics of a class
+    | Also denotes the end of a list of statements and/or expressions
 
 ## Type
 

docs/spec/grammar.md

@@ -11,15 +11,15 @@ The grammar of the language in Extended Backus-Naur Form (EBNF).
 - ```{ ... }``` = zero or more
 
 ```ebnf
-    file             ::= block
+    file             ::= { expr-or-stmt }
     import           ::= [ "from" id ] "import" id { "," id } [ as id { "," id } ]
 
-    type-def         ::= "type" type [ ":" type ] ( newline block | "when" [ conditions ] )
-    conditions       ::= ( newline indent { condition newline } dedent | condition )
+    type-def         ::= "type" type [ ":" type ] ( code-block | "when" [ conditions ] )
+    conditions       ::= "[" condition { newline condition } "]" | condition
     condition        ::= expression [ "!" expression ]
     type-tuple       ::= "(" [ type ] { "," type } ")"
     
-    class            ::= "class" id [ fun-args ] [ ":" ( type | type-tuple ) ] ( newline block )
+    class            ::= "class" id [ fun-args ] [ ":" ( type | type-tuple ) ] ( code-block )
     generics         ::= "[" id { "," id } "]"
     
     id               ::= { character }
@@ -28,8 +28,6 @@ The grammar of the language in Extended Backus-Naur Form (EBNF).
     type             ::= ( id [ generics ] | type-tuple ) [ "->" type ]
     type-tuple       ::= "(" [ type { "," type } ] ")"
     
-    block            ::= indent { expr-or-stmt } dedent
-    
     expr-or-stmt     ::= ( statement | expression ) [ comment ]
     statement        ::= control-flow-stmt
                       | definition
@@ -46,7 +44,7 @@ The grammar of the language in Extended Backus-Naur Form (EBNF).
                       | "return" [ expression ]
                       | expression "as" id 
                       | control-flow-expr 
-                      | newline block
+                      | code-block
                       | collection
                       | index
                       | key-value
@@ -74,10 +72,10 @@ The grammar of the language in Extended Backus-Naur Form (EBNF).
 
     variable-def     ::= [ "fin" ] ( id-maybe-type | collection ) [ ":=" expression ] [ forward ]
     operator-def     ::= [ "pure" ] overridable-op [ "(" [ id-maybe-type ] ")" ] "->" type 
-                         [ ":=" ( expr-or-stmt | newline block ) ]
+                         [ ":=" ( expr-or-stmt | code-block ) ]
 
     fun-def          ::= [ "pure" ] id fun-args [ "->" type ] [ raise ] 
-                         [ ":=" ( expr-or-stmt | newline block ) ]
+                         [ ":=" ( expr-or-stmt | code-block ) ]
     fun-args         ::= "(" [ fun-arg ] { "," fun-arg } ")"
     fun-arg          ::= id-maybe-type [ ":=" expression ]
     forward          ::= "forward" id { "," id }
@@ -108,18 +106,20 @@ The grammar of the language in Extended Backus-Naur Form (EBNF).
     e-notation       ::= ( integer | real ) "E" [ "-" ] integer
     string           ::= """ { character } """
     
-    newline-block    ::= newline block | expr-or-stmt
+    code-block       ::= "[" expr-or-statement "]" 
+                      | expr-or-stmt
+                      | "[" newline expr-or-statement { newline expr-or-statement } "]"
     one-or-more-expr ::= expression { "," expression }
     
     control-flow-expr::= if | match
-    if               ::= "if" one-or-more-expr "then" newline-block [ "else" newline-block ]
+    if               ::= "if" one-or-more-expr "then" code-block [ "else" code-block ]
     match            ::= "match" one-or-more-expr "with" newline match-cases
-    match-cases      ::= indent { match-case { newline } } dedent
+    match-cases      ::= match-case | "[" match-case { newline match-case } "]"
     match-case       ::= expression "=>" expr-or-stmt
     
     control-flow-stmt::= while | foreach | "break" | "continue"
-    while            ::= "while" one-or-more-expr "do" newline-block
-    foreach          ::= "for" one-or-more-expr "in" expression "do" newline-block
+    while            ::= "while" one-or-more-expr "do" code-block
+    foreach          ::= "for" one-or-more-expr "in" expression "do" code-block
     
     newline          ::= newline-char
     newline-char     ::= \n | \r\n