Finished all syntax file

Author: Anton-4

examples/AllSyntax/main.roc

@@ -1,4 +1,4 @@
-app [main!] { cli: platform "https://github.com/roc-lang/basic-cli/releases/download/0.19.0/Hj-J_zxz7V9YurCSTFcFdu6cQJie4guzsPMUi5kBYUk.tar.br" }
+app [main!] { cli: platform "https://github.com/roc-lang/basic-cli/releases/download/0.20.0/X73hGh05nNTkDHU06FHC0YfFaQB1pimX7gncRcao5mU.tar.br" }
 
 import cli.Stdout
 import cli.Arg exposing [Arg]
@@ -27,18 +27,18 @@ number_operators = |a, b|
         gt: a > b,
         gteq: a >= b,
         # unary operators
-        neg: -a, # the last item can have a comma too
+        neg: -a,
+        # the last item can have a comma too
     }
 
 boolean_operators : Bool, Bool -> _
-boolean_operators = |a, b|
-    {
-        bool_and: a && b,
-        bool_and_keyword: a and b,
-        bool_or: a || b,
-        bool_or_keyword: a or b,
-        not_a: !a
-    }
+boolean_operators = |a, b| {
+    bool_and: a && b,
+    bool_and_keyword: a and b,
+    bool_or: a || b,
+    bool_or_keyword: a or b,
+    not_a: !a,
+}
 
 pizza_operator : Str, Str -> Str
 pizza_operator = |str_a, str_b|
@@ -49,52 +49,58 @@ patterns = |lst|
     when lst is
         [1, 2, ..] ->
             42
+
         [2, .., 1] ->
             24
+
         [] ->
             0
-        [_head, .. as tail] ->
+
+        [_head, .. as tail] if List.len(tail) > 7 ->
             List.len(tail)
-        # Note: avoid using `_` in a when branch, in general you should try to match all cases explicitly. 
+
+        # Note: avoid using `_` in a when branch, in general you should try to match all cases explicitly.
         _ ->
             100
 
 string_stuff : Str
-string_stuff = 
+string_stuff =
     planet = "Venus"
 
     Str.concat(
         "Hello, ${planet}!",
         """
         This is a multiline string.
-        You can call functions inside $... too: ${Num.to_str(1+1)}
+        You can call functions inside $... too: ${Num.to_str(1 + 1)}
         Unicode escape sequence: \u(00A0)
-        """
+        """,
     )
 
-pattern_match_tag_union : Result {} _ -> Str
+pattern_match_tag_union : Result {} [StdoutErr(Str), Other] -> Str
 pattern_match_tag_union = |result|
     # `Result a b` is the tag union `[Ok a, Err b]` under the hood.
     when result is
         Ok(_) ->
             "Success"
+
         Err(StdoutErr(err)) ->
-            "StdoutErr: ${Inspect.to_str(err)}" 
+            "StdoutErr: ${Inspect.to_str(err)}"
+
         Err(_) ->
             "Unknown error"
 
-# TODO when branch with tag union, strings, tuples...
-
 # end name with `!` for effectful functions
-# `=>` shows effectfulness in the type signature 
-effect_demo! : Str => Result {} [ StdoutErr(_), StdoutLineFailed [StdoutErr _] ]
+# `=>` shows effectfulness in the type signature
+effect_demo! : Str => Result {} [StdoutErr _, StdoutLineFailed [StdoutErr _]]
 effect_demo! = |msg|
 
     # `?` to return the error if there is one
     Stdout.line!(msg)?
-    
+
     # ` ? ` for map_err
     Stdout.line!(msg) ? |err| StdoutLineFailed(err)
+    # this also works:
+    Stdout.line!(msg) ? StdoutLineFailed
 
     # ?? to provide default value
     Stdout.line!(msg) ?? {}
@@ -105,19 +111,19 @@ effect_demo! = |msg|
 
     Ok({})
 
-dbg_expect_crash : {} -> {}
-dbg_expect_crash = |{}|
+dbg_expect : {} -> {}
+dbg_expect = |{}|
     a = 42
 
     dbg a
 
     # dbg can forward what it receives
     b = dbg 43
-    
+
     # inline expects get removed in optimized builds!
     expect b == 43
 
-    crash "Avoid using crash in production software!"
+    {}
 
 # Top level expect
 expect 0 == 0
@@ -140,7 +146,6 @@ tuple_demo = |{}|
     # they are allocated on the stack
     ("Roc", 1)
 
-
 tag_union_demo : Str -> [Red, Green, Yellow]
 tag_union_demo = |string|
     when string is
@@ -149,8 +154,35 @@ tag_union_demo = |string|
         # We can't list all possible strings, so we use `_` to match all other cases.
         _ -> Yellow
 
-# TODO: destructuring tuples, records
-# TODO: default value records
+type_var_star : List * -> List _
+type_var_star = |lst| lst
+
+TypeWithTypeVar a : [
+    TagOne,
+    TagTwo Str,
+]a
+
+tag_union_advanced : Str -> TypeWithTypeVar [TagThree, TagFour U64]
+tag_union_advanced = |string|
+    when string is
+        "one" -> TagOne
+        "two" -> TagTwo("hello")
+        "three" -> TagThree
+        # We can't list all possible strings, so we use `_` to match all other cases.
+        _ -> TagFour(42)
+
+default_val_record : { a ?? Str } -> Str
+default_val_record = |{ a ?? "default" }|
+    a
+
+destructuring =
+    tup = ("Roc", 1)
+    (str, num) = tup
+
+    rec = { x: 1, y: 2 }
+    { x, y } = rec
+
+    (str, num, x, y)
 
 main! : List Arg => Result {} _
 main! = |_args|
@@ -167,5 +199,14 @@ main! = |_args|
     Stdout.line!("${Inspect.to_str(if_demo(Bool.true))}")?
     Stdout.line!("${Inspect.to_str(tuple_demo({}))}")?
     Stdout.line!("${Inspect.to_str(tag_union_demo("red"))}")?
-    Stdout.line!("${Inspect.to_str(dbg_expect_crash({}))}")
+    Stdout.line!("${Inspect.to_str(type_var_star([1, 2]))}")?
+    Stdout.line!("${Inspect.to_str(tag_union_advanced("four"))}")?
+    Stdout.line!("${default_val_record({})}")?
+    Stdout.line!("${Inspect.to_str(destructuring)}")?
+    Stdout.line!("${Inspect.to_str(dbg_expect({}))}")?
+
+    # Commented out so CI tests can pass
+    # crash "Avoid using crash in production software!"
+
+    Ok({})