-> replaced with =>, added -> (in) in reference_expression, reference -> reference_expression

corpus/test.langexp

@@ -10,32 +10,33 @@ Test
 :: module_namespace = module;
 
 func = {
-  @-> {
+
+  @=> {
     %x := scan;
-    ?? x == ''x'' -> break;
+    ?? x == ''x'' => break;
   };
 
-  @ i < 10 -> {
+  @ i < 10 => {
     inc i;
   };
 
-  @ %x : 1..10 -> {
+  @ %x : 1..10 => {
     print "Hello  World!\n";
   };
 
   ?? abracadabbra < abracadabra_abracadabra || some_long_name == another_long_name
-  &&. abracadabra-abracadabra < long_long_long_long_name -> io.print x
-  !! x < 0 -> {
+  &&. abracadabra-abracadabra < long_long_long_long_name => io.print x
+  !! x < 0 => {
     x += 1;
     io.print y;
-  } !!-> return ();
+  } !!=> return ();
 }
 
 : example of function with optional arguments (without type annotation)
 : real type is 'A? 'A? -> 'A?
 sum 'a? 'b? =
-  'a & 'b =: %a? & %b? -> a + b
-          =: _ -> null;
+  'a & 'b =: %a? & %b? => a + b
+          =: _ => null;
 
 
 : example that shows that default annotations are argument names (without ')
@@ -49,34 +50,34 @@ sum 'a 'b = 'a + 'b;
 @n is position in Fibonacci sequence
 ? 'n >= 0;
 fib @n 'n : Int -> Int =
-  'n =: 0 | 1 -> 1
-     =: _ -> fib ('n - 1) + fib 'n;
+  'n =: 0 | 1 => 1
+     =: _ => fib ('n - 1) + fib 'n;
 
 func_2 = {
   %variant := x;
 
   %val | %err := f x;
 
-  %lambda1 := \'x 'y -> 'x + 'y;
+  %lambda1 := \'x 'y => 'x + 'y;
 
-  %lambda2 := \ -> 3;
+  %lambda2 := \ => 3;
 
-  variant =: 1 | 2 -> "a"
-          =: 3..10 -> "b"
-          =: 45 | 55 | x ?? x > 100 -> "c"
-          =: _ -> "another variants";
+  variant =: 1 | 2 => "a"
+          =: 3..10 => "b"
+          =: 45 | 55 | x ?? x > 100 => "c"
+          =: _ => "another variants";
 
   // all var arrays are dynamic
   $array := [[x y z]];
   array.push a;
 
-  %x := maybe_something -> do_something
-  !!-> do_something_another;
+  %x := maybe_something => do_something
+     := _ => do_something_another;
 
   %x := Task @name "do something" @duration 123.1;
 
   // open optional: execute expression only if not null
-  %x? := maybe_something -> do_something;
+  %x? := maybe_something => do_something;
 
   // open optional: return null to all outputs (all outputs should be optional values)
   %x? := maybe_something;
@@ -95,9 +96,9 @@ func_2 = {
 
   %y := Fruit @apple ();
 
-  y =: Fruit @apple () -> "apple"
-    =: Fruit @orange () -> "orange"
-    =: Fruit @banana () -> "banana";
+  y =: Fruit @apple () => "apple"
+    =: Fruit @orange () => "orange"
+    =: Fruit @banana () => "banana";
 
   %z := ( + ) 1 2;
 
@@ -131,9 +132,9 @@ Fruit = @apple Unit
 : function that takes array reference argument
 bubble_sort 'arr : <> Array['A] = {
   swap_occured := true;
-  @ swap_occured -> {
+  @ swap_occured => {
     swap_occured = false;
-    @ %i : 0 .. 'arr.size -> (?? 'arr[i] > 'arr[i + 1] -> swap 'arr[i] 'arr[i + 1], swap_occured = true);
+    @ %i : 0 .. 'arr.size => (?? 'arr[i] > 'arr[i + 1] => swap 'arr[i] 'arr[i + 1], swap_occured = true);
   };
 }
 
@@ -484,12 +485,12 @@ arg_deduction_example 'name 'duration : <- String <- Float -> Task = Task 'name
         (case
           (name_expression
             (simple_name_identifier))
-          (operator_expression
-            (name_expression
-              (simple_name_identifier))
-            (operator)
-            (name_expression
-              (simple_name_identifier)))))
+          (name_expression
+            (simple_name_identifier)))
+        (case
+          (placeholder)
+          (name_expression
+            (simple_name_identifier))))
       (match
         (name_definition
           (simple_name_identifier))
@@ -910,7 +911,7 @@ arg_deduction_example 'name 'duration : <- String <- Float -> Task = Task 'name
         (name_definition
           (simple_name_identifier))
         (case
-          (reference
+          (reference_expression
             (array_access
               (simple_name_identifier)
               (number_literal)))))))
@@ -941,19 +942,19 @@ arg_deduction_example 'name 'duration : <- String <- Float -> Task = Task 'name
           (name_definition
             (simple_name_identifier))
           (case
-            (reference
+            (reference_expression
               (argument_name_identifier))))
         (match
           (name_expression
             (argument_name_identifier))
           (case
-            (reference
+            (reference_expression
               (argument_name_identifier)))))
       (match
         (name_expression
           (argument_name_identifier))
         (case
-          (reference
+          (reference_expression
             (simple_name_identifier))))))
   (function_definition
     (definition_info)
@@ -966,19 +967,19 @@ arg_deduction_example 'name 'duration : <- String <- Float -> Task = Task 'name
           (name_definition
             (simple_name_identifier))
           (case
-            (reference
+            (reference_expression
               (argument_name_identifier))))
         (match
           (name_expression
             (argument_name_identifier))
           (case
-            (reference
+            (reference_expression
               (argument_name_identifier)))))
       (match
         (name_expression
           (argument_name_identifier))
         (case
-          (reference
+          (reference_expression
             (simple_name_identifier))))))
   (function_definition
     (definition_info)