mirror of
https://codeberg.org/ProgramSnail/tree-sitter-lang.git
synced 2025-12-06 06:38:51 +00:00
1246 lines
32 KiB
Text
1246 lines
32 KiB
Text
================================================================================
|
|
Test
|
|
================================================================================
|
|
|
|
#!/usr/bin/env lang
|
|
|
|
:: module; // import module to current namespace
|
|
|
|
:: _ = module_2; // import module to current namespace and use functions inside without namespace
|
|
|
|
:: module_3 : func1 func2 func3;
|
|
:: module_namespace = module_4;
|
|
|
|
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_2 '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;
|
|
}
|
|
|
|
: operator definition example
|
|
( - ) 'a 'b = 'a + neg 'b;
|
|
|
|
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_2 '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);
|
|
};
|
|
}
|
|
|
|
: 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] {
|
|
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;
|
|
|
|
: previous example with automatic type deduction
|
|
swap_2 <> 'a <> 'b = %c := <- 'a, 'a := <- 'b, 'b := <- c;
|
|
|
|
: 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;
|
|
}
|
|
|
|
: function, that takes result argument
|
|
result_example 'a! = 'a =: _? => print "value inside"
|
|
=: _ => print "error inside";
|
|
|
|
: function, that returns result
|
|
parse_number : Unit! = {
|
|
%number_str := String.scan;
|
|
%number! := Int.parse number_str;
|
|
number.print;
|
|
bring ();
|
|
}
|
|
|
|
: example of or_in and or_out usage for template operators (tuple input and tuple output)
|
|
( & ) --|-> 'a --|-> 'b <-|-- 'x <-|-- 'y = ('a := 'x) && ('b := 'y);
|
|
|
|
: function, that return result ('!' not used on calls)
|
|
: useful when tuples returned
|
|
result_func! 'a 'b -> 'c -> 'd = ?? 'a == 0 => error "some error" !!=> ('c := 'a, 'd := 'b, ());
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
(source_file
|
|
(empty_lines)
|
|
(import
|
|
(simple_name_identifier))
|
|
(empty_lines)
|
|
(import
|
|
(placeholder)
|
|
(simple_name_identifier))
|
|
(empty_lines)
|
|
(import
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))
|
|
(import
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))
|
|
(empty_lines)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(block
|
|
(empty_lines)
|
|
(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))))
|
|
(empty_lines)
|
|
(loop
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(number_literal))
|
|
(block
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(loop
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(operator_expression
|
|
(number_literal)
|
|
(operator)
|
|
(number_literal))
|
|
(block
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(string_literal))))
|
|
(empty_lines)
|
|
(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)))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info)
|
|
(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))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(annotation_info
|
|
(annotation_identifier)
|
|
(info))
|
|
(annotation_info
|
|
(annotation_identifier)
|
|
(info))
|
|
(simple_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(operator)
|
|
(name_expression
|
|
(argument_name_identifier))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info)
|
|
(info)
|
|
(info))
|
|
(annotation_info
|
|
(annotation_identifier)
|
|
(info))
|
|
(constraint
|
|
(operator_expression
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(operator)
|
|
(number_literal)))
|
|
(simple_name_identifier)
|
|
(argument_name_identifier)
|
|
(annotation_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))))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(block
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(match
|
|
(operator_expression
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(name_definition
|
|
(simple_name_identifier)))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(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))))))
|
|
(empty_lines)
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(lambda
|
|
(number_literal))))
|
|
(empty_lines)
|
|
(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)))
|
|
(empty_lines)
|
|
(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))
|
|
(empty_lines)
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(name_expression
|
|
(simple_name_identifier)))
|
|
(case
|
|
(placeholder)
|
|
(name_expression
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(constructor
|
|
(type
|
|
(simple_type_identifier))
|
|
(annotation_identifier)
|
|
(string_literal)
|
|
(annotation_identifier)
|
|
(float_number_literal))))
|
|
(empty_lines)
|
|
(match
|
|
(suffix_expression
|
|
(name_definition
|
|
(simple_name_identifier)))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(name_expression
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(match
|
|
(suffix_expression
|
|
(name_definition
|
|
(simple_name_identifier)))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(match
|
|
(suffix_expression
|
|
(name_definition
|
|
(simple_name_identifier)))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(suffix_expression
|
|
(simple_name_identifier))
|
|
(empty_lines)
|
|
(suffix_expression
|
|
(simple_name_identifier))
|
|
(empty_lines)
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(name_expression
|
|
(simple_name_identifier)))))
|
|
(empty_lines)
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(constructor
|
|
(type
|
|
(simple_type_identifier))
|
|
(annotation_identifier)
|
|
(unit_literal))))
|
|
(empty_lines)
|
|
(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)))
|
|
(empty_lines)
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(operator)
|
|
(number_literal)
|
|
(number_literal))))
|
|
(empty_lines)
|
|
(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)))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(operator)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(operator)
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(argument_name_identifier))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(block
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(block
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(block
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))))
|
|
(empty_lines)
|
|
(type_definition
|
|
(simple_type_identifier)
|
|
(variant_type
|
|
(tuple_type
|
|
(annotation_identifier)
|
|
(type
|
|
(simple_type_identifier))
|
|
(annotation_identifier)
|
|
(type
|
|
(simple_type_identifier)))))
|
|
(empty_lines)
|
|
(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)))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(name_expression
|
|
(simple_name_identifier)))
|
|
(operator)
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(number_literal))))
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(name_expression
|
|
(simple_name_identifier)))
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(number_literal)))))
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(bool_literal))))))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(name_expression
|
|
(simple_name_identifier)))
|
|
(operator)
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(number_literal))))
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(name_expression
|
|
(simple_name_identifier)))
|
|
(array_access
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(number_literal)))))
|
|
(operator_expression
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(operator)
|
|
(bool_literal))))))))
|
|
(empty_lines)
|
|
(type_definition
|
|
(definition_info
|
|
(info)
|
|
(info))
|
|
(simple_type_identifier)
|
|
(argument_type_identifier)
|
|
(argument_type_identifier)
|
|
(variant_type
|
|
(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)))))
|
|
(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))))
|
|
(empty_lines)
|
|
(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))))))
|
|
(empty_lines)
|
|
(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)))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(block
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(reference_expression
|
|
(array_access
|
|
(simple_name_identifier)
|
|
(number_literal)))))))
|
|
(empty_lines)
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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_expression
|
|
(argument_name_identifier))))
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(reference_expression
|
|
(argument_name_identifier)))))
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(reference_expression
|
|
(simple_name_identifier))))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(simple_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(comma_expression
|
|
(comma_expression
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(reference_expression
|
|
(argument_name_identifier))))
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(reference_expression
|
|
(argument_name_identifier)))))
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(reference_expression
|
|
(simple_name_identifier))))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(simple_name_identifier)
|
|
(argument_name_identifier)
|
|
(type
|
|
(simple_type_identifier))
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(simple_name_identifier)))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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)))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(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)))
|
|
(empty_lines)
|
|
(typeclass_definition
|
|
(definition_info
|
|
(info))
|
|
(typeclass_identifier)
|
|
(typeclass_identifier)
|
|
(function_definition
|
|
(simple_name_identifier)
|
|
(type
|
|
(simple_type_identifier))
|
|
(type
|
|
(simple_type_identifier))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(simple_name_identifier)
|
|
(argument_name_identifier)
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(suffix_expression
|
|
(placeholder))
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(string_literal)))
|
|
(case
|
|
(placeholder)
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(string_literal)))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(simple_name_identifier)
|
|
(type
|
|
(simple_type_identifier))
|
|
(block
|
|
(match
|
|
(name_definition
|
|
(simple_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(type
|
|
(simple_type_identifier))
|
|
(simple_name_identifier))))
|
|
(match
|
|
(suffix_expression
|
|
(name_definition
|
|
(simple_name_identifier)))
|
|
(case
|
|
(name_expression
|
|
(type
|
|
(simple_type_identifier))
|
|
(simple_name_identifier)
|
|
(simple_name_identifier))))
|
|
(name_expression
|
|
(simple_name_identifier))
|
|
(return
|
|
(unit_literal))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info))
|
|
(operator)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(operator_expression
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(argument_name_identifier))))
|
|
(operator)
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(argument_name_identifier))))))
|
|
(empty_lines)
|
|
(function_definition
|
|
(definition_info
|
|
(info)
|
|
(info))
|
|
(simple_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(argument_name_identifier)
|
|
(condition
|
|
(operator_expression
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(operator)
|
|
(number_literal))
|
|
(name_expression
|
|
(simple_name_identifier)
|
|
(string_literal))
|
|
(comma_expression
|
|
(comma_expression
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(argument_name_identifier))))
|
|
(match
|
|
(name_expression
|
|
(argument_name_identifier))
|
|
(case
|
|
(name_expression
|
|
(argument_name_identifier)))))
|
|
(unit_literal)))))
|