================================================================================
Test
================================================================================

:: module; // import module to current namespace

:: _ = module; // import module to current namespace and use functions inside without namespace

:: module : func1 func2 func3;
:: module_namespace = module;

func = {
  @-> {
    %x := scan;
    ?? x == ''x'' -> break;
  };

  @ i < 10 -> {
    inc i;
  };

  @ %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 -> {
    x += 1;
    io.print y;
  } !!-> 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;


: example that shows that default annotations are argument names (without ')
@a is integer
@b also integer
sum 'a 'b = 'a + 'b;

: this function can be used to calculate Fibonacci sequence elements
: it is important is some algorithmic tasks
: also this is example of function constraint
@n is position in Fibonacci sequence
? 'n >= 0;
fib @n 'n : Int -> Int =
  'n =: 0 | 1 -> 1
     =: _ -> fib ('n - 1) + fib 'n;

func_2 = {
  %variant := x;

  %val | %err := f x;

  %lambda1 := \'x 'y -> 'x + 'y;

  %lambda2 := \ -> 3;

  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 := Task @name "do something" @duration 123.1;

  // open optional: execute expression only if not null
  %x? := maybe_something -> do_something;

  // open optional: return null to all outputs (all outputs should be optional values)
  %x? := maybe_something;

  // open optional: panic on null
  %x! := maybe_something;

  // open optional: return null to all outputs (all outputs should be optional values)
  maybe_something?;

  // open optional: panic on null
  maybe_something!;

  // open optional: if null then return default value (operator)
  %x := maybe_something ?| value

  %y := Fruit @apple ();

  y =: Fruit @apple () -> "apple"
    =: Fruit @orange () -> "orange"
    =: Fruit @banana () -> "banana";

  %z := ( + ) 1 2;

  // tuple access
  %t := 1 & 2 & 3;
  print t.0;
}

test.something = {
  do_something a b c;
}

exec.something = {
  do_something a b c;
}

example.something = {
  do_something a b c;
}

Task = @name String
     & @duration Float;

Fruit = @apple Unit
      | @orange Unit
      | @banana Unit;

: function that takes array reference argument
bubble_sort 'arr : <> Array['A] = {
  swap_occured := true;
  @ swap_occured -> {
    swap_occured = false;
    @ %i : 0 .. 'arr.size -> (?? 'arr[i] > 'arr[i + 1] -> swap 'arr[i] 'arr[i + 1], swap_occured = true);
  };
}

: bubble_sort with names instead of symbols
bubble_sort 'arr : ref Array['A] = {
  var swap_occured := true;
  for swap_occured do {
    swap_occured = false;
    for let i : 0 .. 'arr.size do (if 'arr[i] > 'arr[i + 1] do swap 'arr[i] 'arr[i + 1], swap_occured = true);
  };
}

merge_sort 'arr : <> Array['A] = {

}

: example of ^ and generics. ^ used to denote that this object allocated on heap
: object allocated by unique reference by default
^TreeNode 'Key 'Value =
  & @key Key
  & @value Value
  & @left ^TreeNode['Key 'Value]
  & @right ^TreeNode['Key 'Value];

TreeNode {
  new = do_something; // static methods

  $insert 'key = do_something; // const methods

  %find 'key = do_something;

  $delete 'key = do_something; // var methods
}

generic_type_name_expressions = {
  $x := TreeNode[Int Int].new;
  $y := std.Array[Int].new;
}

pipes_example = {
  expr |> func_1 a b |> func_2 c d |> print; // print (func_2 (func_1 expr a b) c d)
  print <| func_1 a b <| func_2 c d <| expr; // print (func_1 a b (func_2 c d expr))
}

test_ref_access_precendence = {
  %x := <> arr[123];
}

// by default constant arguments are used

: constant arguments example, type - 'A 'B
print_two 'a 'b = print 'a, print 'b;

: example of reference args and comma operator
swap 'a 'b : <> 'A <> 'A = %c := <- 'a, 'a := <- 'b, 'b := <- c; // TODO: use move in some way ??

: several outputs example
scan_three : -> String -> String -> String = scan & scan & scan;

: output by argument
scan_to_variable 'a : -> String = 'a := scan;

: consuming input example
move_construct_task 'name 'duration : <- String <- Float -> Task = Task @name 'name @duration 'duration;

: copy constructing, field annotations deduced
arg_deduction_example 'name 'duration : <- String <- Float -> Task = Task 'name 'duration;

: ord is fundamental typeclass
#Ord : #Eq {
  $is_less_then : Ord -> Bool;
}

--------------------------------------------------------------------------------

(source_file
  (import
    (simple_name_identifier))
  (import
    (simple_name_identifier))
  (import
    (simple_name_identifier)
    (simple_name_identifier)
    (simple_name_identifier)
    (simple_name_identifier))
  (import
    (simple_name_identifier)
    (simple_name_identifier))
  (function_definition
    (simple_name_identifier)
    (block
      (loop
        (block
          (match
            (name_definition
              (simple_name_identifier))
            (case
              (name_expression
                (simple_name_identifier))))
          (condition
            (operator_expression
              (name_expression
                (simple_name_identifier))
              (operator)
              (char_literal))
            (loop_control))))
      (loop
        (operator_expression
          (name_expression
            (simple_name_identifier))
          (operator)
          (number_literal))
        (block
          (name_expression
            (simple_name_identifier)
            (simple_name_identifier))))
      (loop
        (name_definition
          (simple_name_identifier))
        (operator_expression
          (number_literal)
          (operator)
          (number_literal))
        (block
          (name_expression
            (simple_name_identifier)
            (string_literal))))
      (condition
        (operator_expression
          (operator_expression
            (operator_expression
              (operator_expression
                (name_expression
                  (simple_name_identifier))
                (operator)
                (name_expression
                  (simple_name_identifier)))
              (operator)
              (name_expression
                (simple_name_identifier)))
            (operator)
            (name_expression
              (simple_name_identifier)))
          (operator_tail1)
          (operator_expression
            (operator_expression
              (name_expression
                (simple_name_identifier))
              (operator)
              (name_expression
                (simple_name_identifier)))
            (operator)
            (name_expression
              (simple_name_identifier))))
        (name_expression
          (simple_name_identifier)
          (simple_name_identifier))
        (operator_expression
          (name_expression
            (simple_name_identifier))
          (operator)
          (number_literal))
        (block
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (number_literal))
          (name_expression
            (simple_name_identifier)
            (simple_name_identifier)))
        (return
          (unit_literal)))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (argument_name_identifier)
    (match
      (operator_expression
        (name_expression
          (argument_name_identifier))
        (operator)
        (name_expression
          (argument_name_identifier)))
      (case
        (operator_expression
          (suffix_expression
            (name_definition
              (simple_name_identifier)))
          (operator)
          (suffix_expression
            (name_definition
              (simple_name_identifier))))
        (operator_expression
          (name_expression
            (simple_name_identifier))
          (operator)
          (name_expression
            (simple_name_identifier))))
      (case
        (placeholder)
        (null_literal))))
  (function_definition
    (definition_info)
    (annotation_info
      (annotation_identifier))
    (annotation_info
      (annotation_identifier))
    (simple_name_identifier)
    (argument_name_identifier)
    (argument_name_identifier)
    (operator_expression
      (name_expression
        (argument_name_identifier))
      (operator)
      (name_expression
        (argument_name_identifier))))
  (function_definition
    (definition_info)
    (annotation_info
      (annotation_identifier))
    (constraint
      (operator_expression
        (name_expression
          (argument_name_identifier))
        (operator)
        (number_literal)))
    (simple_name_identifier)
    (annotation_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (match
      (name_expression
        (argument_name_identifier))
      (case
        (operator_expression
          (number_literal)
          (operator)
          (number_literal))
        (number_literal))
      (case
        (placeholder)
        (operator_expression
          (name_expression
            (simple_name_identifier)
            (operator_expression
              (name_expression
                (argument_name_identifier))
              (operator)
              (number_literal)))
          (operator)
          (name_expression
            (simple_name_identifier)
            (argument_name_identifier))))))
  (function_definition
    (simple_name_identifier)
    (block
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (name_expression
            (simple_name_identifier))))
      (match
        (operator_expression
          (name_definition
            (simple_name_identifier))
          (operator)
          (name_definition
            (simple_name_identifier)))
        (case
          (name_expression
            (simple_name_identifier)
            (simple_name_identifier))))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (lambda
            (argument_name_identifier)
            (argument_name_identifier)
            (operator_expression
              (name_expression
                (argument_name_identifier))
              (operator)
              (name_expression
                (argument_name_identifier))))))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (lambda
            (number_literal))))
      (match
        (name_expression
          (simple_name_identifier))
        (case
          (operator_expression
            (number_literal)
            (operator)
            (number_literal))
          (string_literal))
        (case
          (operator_expression
            (number_literal)
            (operator)
            (number_literal))
          (string_literal))
        (case
          (operator_expression
            (operator_expression
              (number_literal)
              (operator)
              (number_literal))
            (operator)
            (name_expression
              (simple_name_identifier)))
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (number_literal))
          (string_literal))
        (case
          (placeholder)
          (string_literal)))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (array
            (simple_name_identifier)
            (simple_name_identifier)
            (simple_name_identifier))))
      (name_expression
        (simple_name_identifier)
        (simple_name_identifier))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (name_expression
            (simple_name_identifier))
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (name_expression
              (simple_name_identifier)))))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (constructor
            (type
              (simple_type_identifier))
            (annotation_identifier)
            (string_literal)
            (annotation_identifier)
            (float_number_literal))))
      (match
        (suffix_expression
          (name_definition
            (simple_name_identifier)))
        (case
          (name_expression
            (simple_name_identifier))
          (name_expression
            (simple_name_identifier))))
      (match
        (suffix_expression
          (name_definition
            (simple_name_identifier)))
        (case
          (name_expression
            (simple_name_identifier))))
      (match
        (suffix_expression
          (name_definition
            (simple_name_identifier)))
        (case
          (name_expression
            (simple_name_identifier))))
      (suffix_expression
        (simple_name_identifier))
      (suffix_expression
        (simple_name_identifier))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (name_expression
              (simple_name_identifier)
              (name_definition
                (simple_name_identifier)))))
        (case
          (constructor
            (type
              (simple_type_identifier))
            (annotation_identifier)
            (unit_literal))))
      (match
        (name_expression
          (simple_name_identifier))
        (case
          (constructor
            (type
              (simple_type_identifier))
            (annotation_identifier)
            (unit_literal))
          (string_literal))
        (case
          (constructor
            (type
              (simple_type_identifier))
            (annotation_identifier)
            (unit_literal))
          (string_literal))
        (case
          (constructor
            (type
              (simple_type_identifier))
            (annotation_identifier)
            (unit_literal))
          (string_literal)))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (name_expression
            (operator)
            (number_literal)
            (number_literal))))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (operator_expression
            (operator_expression
              (number_literal)
              (operator)
              (number_literal))
            (operator)
            (number_literal))))
      (name_expression
        (simple_name_identifier)
        (tuple_access
          (simple_name_identifier)
          (number_literal)))))
  (function_definition
    (simple_name_identifier)
    (block
      (name_expression
        (simple_name_identifier)
        (simple_name_identifier)
        (simple_name_identifier)
        (simple_name_identifier))))
  (function_definition
    (simple_name_identifier)
    (block
      (name_expression
        (simple_name_identifier)
        (simple_name_identifier)
        (simple_name_identifier)
        (simple_name_identifier))))
  (function_definition
    (simple_name_identifier)
    (block
      (name_expression
        (simple_name_identifier)
        (simple_name_identifier)
        (simple_name_identifier)
        (simple_name_identifier))))
  (type_definition
    (simple_type_identifier)
    (tuple_type
      (annotation_identifier)
      (type
        (simple_type_identifier))
      (annotation_identifier)
      (type
        (simple_type_identifier))))
  (type_definition
    (simple_type_identifier)
    (variant_type
      (tuple_type
        (annotation_identifier)
        (type
          (simple_type_identifier)))
      (tuple_type
        (annotation_identifier)
        (type
          (simple_type_identifier)))
      (tuple_type
        (annotation_identifier)
        (type
          (simple_type_identifier)))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier)
      (type
        (argument_type_identifier)))
    (block
      (match
        (name_expression
          (simple_name_identifier))
        (case
          (bool_literal)))
      (loop
        (name_expression
          (simple_name_identifier))
        (block
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (bool_literal))
          (loop
            (name_definition
              (simple_name_identifier))
            (operator_expression
              (number_literal)
              (operator)
              (name_expression
                (argument_name_identifier)
                (simple_name_identifier)))
            (comma_expression
              (condition
                (operator_expression
                  (access
                    (argument_name_identifier)
                    (name_expression
                      (simple_name_identifier)))
                  (operator)
                  (access
                    (argument_name_identifier)
                    (operator_expression
                      (name_expression
                        (simple_name_identifier))
                      (operator)
                      (number_literal))))
                (name_expression
                  (simple_name_identifier)
                  (access
                    (argument_name_identifier)
                    (name_expression
                      (simple_name_identifier)))
                  (access
                    (argument_name_identifier)
                    (operator_expression
                      (name_expression
                        (simple_name_identifier))
                      (operator)
                      (number_literal)))))
              (operator_expression
                (name_expression
                  (simple_name_identifier))
                (operator)
                (bool_literal))))))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier)
      (type
        (argument_type_identifier)))
    (block
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (bool_literal)))
      (loop
        (name_expression
          (simple_name_identifier))
        (block
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (bool_literal))
          (loop
            (name_definition
              (simple_name_identifier))
            (operator_expression
              (number_literal)
              (operator)
              (name_expression
                (argument_name_identifier)
                (simple_name_identifier)))
            (comma_expression
              (condition
                (operator_expression
                  (access
                    (argument_name_identifier)
                    (name_expression
                      (simple_name_identifier)))
                  (operator)
                  (access
                    (argument_name_identifier)
                    (operator_expression
                      (name_expression
                        (simple_name_identifier))
                      (operator)
                      (number_literal))))
                (name_expression
                  (simple_name_identifier)
                  (access
                    (argument_name_identifier)
                    (name_expression
                      (simple_name_identifier)))
                  (access
                    (argument_name_identifier)
                    (operator_expression
                      (name_expression
                        (simple_name_identifier))
                      (operator)
                      (number_literal)))))
              (operator_expression
                (name_expression
                  (simple_name_identifier))
                (operator)
                (bool_literal))))))))
  (function_definition
    (simple_name_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier)
      (type
        (argument_type_identifier)))
    (block))
  (type_definition
    (definition_info)
    (simple_type_identifier)
    (argument_type_identifier)
    (argument_type_identifier)
    (tuple_type
      (annotation_identifier)
      (type
        (simple_type_identifier))
      (annotation_identifier)
      (type
        (simple_type_identifier))
      (annotation_identifier)
      (type
        (simple_type_identifier)
        (type
          (argument_type_identifier))
        (type
          (argument_type_identifier)))
      (annotation_identifier)
      (type
        (simple_type_identifier)
        (type
          (argument_type_identifier))
        (type
          (argument_type_identifier)))))
  (type_definition
    (simple_type_identifier)
    (function_definition
      (simple_name_identifier)
      (name_expression
        (simple_name_identifier)))
    (function_definition
      (simple_name_identifier)
      (argument_name_identifier)
      (name_expression
        (simple_name_identifier)))
    (function_definition
      (simple_name_identifier)
      (argument_name_identifier)
      (name_expression
        (simple_name_identifier)))
    (function_definition
      (simple_name_identifier)
      (argument_name_identifier)
      (name_expression
        (simple_name_identifier))))
  (function_definition
    (simple_name_identifier)
    (block
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (name_expression
            (type
              (simple_type_identifier)
              (type
                (simple_type_identifier))
              (type
                (simple_type_identifier)))
            (simple_name_identifier))))
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (name_expression
            (type
              (simple_type_identifier)
              (type
                (simple_type_identifier)))
            (simple_name_identifier))))))
  (function_definition
    (simple_name_identifier)
    (block
      (operator_expression
        (operator_expression
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (name_expression
              (simple_name_identifier)
              (simple_name_identifier)
              (simple_name_identifier)))
          (operator)
          (name_expression
            (simple_name_identifier)
            (simple_name_identifier)
            (simple_name_identifier)))
        (operator)
        (name_expression
          (simple_name_identifier)))
      (operator_expression
        (operator_expression
          (operator_expression
            (name_expression
              (simple_name_identifier))
            (operator)
            (name_expression
              (simple_name_identifier)
              (simple_name_identifier)
              (simple_name_identifier)))
          (operator)
          (name_expression
            (simple_name_identifier)
            (simple_name_identifier)
            (simple_name_identifier)))
        (operator)
        (name_expression
          (simple_name_identifier)))))
  (function_definition
    (simple_name_identifier)
    (block
      (match
        (name_definition
          (simple_name_identifier))
        (case
          (reference
            (access
              (simple_name_identifier)
              (number_literal)))))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (argument_name_identifier)
    (comma_expression
      (name_expression
        (simple_name_identifier)
        (argument_name_identifier))
      (name_expression
        (simple_name_identifier)
        (argument_name_identifier))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (argument_name_identifier)
    (type
      (argument_type_identifier))
    (type
      (argument_type_identifier))
    (comma_expression
      (comma_expression
        (match
          (name_definition
            (simple_name_identifier))
          (case
            (reference
              (argument_name_identifier))))
        (match
          (name_expression
            (argument_name_identifier))
          (case
            (reference
              (argument_name_identifier)))))
      (match
        (name_expression
          (argument_name_identifier))
        (case
          (reference
            (simple_name_identifier))))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (operator_expression
      (operator_expression
        (name_expression
          (simple_name_identifier))
        (operator)
        (name_expression
          (simple_name_identifier)))
      (operator)
      (name_expression
        (simple_name_identifier))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier))
    (match
      (name_expression
        (argument_name_identifier))
      (case
        (name_expression
          (simple_name_identifier)))))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (constructor
      (type
        (simple_type_identifier))
      (annotation_identifier)
      (argument_name_identifier)
      (annotation_identifier)
      (argument_name_identifier)))
  (function_definition
    (definition_info)
    (simple_name_identifier)
    (argument_name_identifier)
    (argument_name_identifier)
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (type
      (simple_type_identifier))
    (constructor
      (type
        (simple_type_identifier))
      (argument_name_identifier)
      (argument_name_identifier)))
  (typeclass_definition
    (definition_info)
    (typeclass_identifier)
    (typeclass_identifier)
    (function_definition
      (simple_name_identifier)
      (type
        (simple_type_identifier))
      (type
        (simple_type_identifier)))))