==================
Declarations
==================

immutable :: 1
mutable := 2
typed: i32: 3
deferred: i32

---

(source_file
  (declaration
    (identifier)
    (signed_numeric_literal
      (integer_literal)))
  (declaration
    (identifier)
    (signed_numeric_literal
      (integer_literal)))
  (declaration
    (identifier)
    (primitive_type)
    (signed_numeric_literal
      (integer_literal)))
  (declaration
    (identifier)
    (primitive_type)))

==================
Types and constructors
==================

Point :: &{
    x: i32:
    y: i32 = 0
}
point := &Point.{ x: 1; y = 2 }
maybe: []{i32?}: [nil, some 1]

---

(source_file
  (declaration
    (identifier)
    (type_definition
      (product_type
        (product_field
          (identifier)
          (primitive_type))
        (product_field
          (identifier)
          (primitive_type)
          (signed_numeric_literal
            (integer_literal))))))
  (declaration
    (identifier)
    (product_constructor
      (identifier)
      (product_entry
        (identifier)
        (signed_numeric_literal
          (integer_literal)))
      (product_entry
        (identifier)
        (signed_numeric_literal
          (integer_literal)))))
  (declaration
    (identifier)
    (array_type
      (grouped_type
        (optional_type
          (primitive_type))))
    (collection_literal
      (collection_entry
        (nil_literal))
      (collection_entry
        (unary_expression
          (signed_numeric_literal
            (integer_literal)))))))

==================
Control flow and patterns
==================

describe: []i32 -> str: @ values: []i32 { match values {
    [] => 'empty'
    [first, ...rest] if first > 0 => 'positive'
    _ => 'other'
} }

---

(source_file
  (declaration
    (identifier)
    (function_type
      (array_type
        (primitive_type))
      (primitive_type))
    (function_literal
      (typed_parameter
        (identifier)
        (array_type
          (primitive_type)))
      (block
        (match_expression
          (identifier)
          (match_arm
            (pattern
              (array_pattern))
            (string_literal))
          (match_arm
            (pattern
              (array_pattern
                (array_pattern_entry
                  (pattern
                    (identifier)))
                (array_pattern_entry
                  (identifier))))
            (binary_expression
              (identifier)
              (signed_numeric_literal
                (integer_literal)))
            (string_literal))
          (match_arm
            (pattern)
            (string_literal)))))))

==================
Physical-line continuations
==================

value := 'text' # the newline remains significant
->reverse_chrs

ready :: first
    and second

---

(source_file
  (declaration
    (identifier)
    (pipeline_expression
      (string_literal)
      (comment)
      (continuation_pipeline_stage
        (pipeline_callable
          (identifier)))))
  (declaration
    (identifier)
    (binary_expression
      (identifier)
      (identifier))))

==================
Compact range after an integer
==================

slice :: (source,0..<limit)
trailing_dot :: 1.

---

(source_file
  (declaration
    (identifier)
    (tuple_value
      (identifier)
      (range_expression
        (signed_numeric_literal
          (integer_literal))
        (identifier))))
  (declaration
    (identifier)
    (signed_numeric_literal
      (float_literal))))

==================
Typed function declarations
==================

double :: @ value: i32 { value * 2 }
square :: @ value: i32 => i32 { value * value }
add :: @ (left: i32, right: i32) { left + right }
unit :: @ { () }

---

(source_file
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier)
        (primitive_type))
      (block
        (binary_expression
          (identifier)
          (signed_numeric_literal
            (integer_literal))))))
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier)
        (primitive_type))
      (primitive_type)
      (block
        (binary_expression
          (identifier)
          (identifier)))))
  (declaration
    (identifier)
    (function_literal
      (typed_tuple_pattern
        (typed_tuple_component
          (identifier)
          (primitive_type))
        (typed_tuple_component
          (identifier)
          (primitive_type)))
      (block
        (binary_expression
          (identifier)
          (identifier)))))
  (declaration
    (identifier)
    (function_literal
      (block
        (unit_literal)))))

==================
Whole-argument function patterns
==================

pair :: @ (left, right): (i32, i32) { left + right }
product :: @ {value}: &{value: i32:} { value }
callback :: @ operation: {i32 -> i32} { 1->operation }
unit :: @ () -> i32 { 42 }

---

(source_file
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (tuple_pattern
          (pattern
            (identifier))
          (pattern
            (identifier)))
        (tuple_type
          (primitive_type)
          (primitive_type)))
      (block
        (binary_expression
          (identifier)
          (identifier)))))
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (product_pattern
          (product_pattern_field
            (identifier)))
        (product_type
          (product_field
            (identifier)
            (primitive_type))))
      (block
        (identifier))))
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier)
        (grouped_type
          (function_type
            (primitive_type)
            (primitive_type))))
      (block
        (pipeline_expression
          (signed_numeric_literal
            (integer_literal))
          (direct_pipeline_stage
            (pipeline_callable
              (identifier)))))))
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (unit_pattern))
      (primitive_type)
      (block
        (signed_numeric_literal
          (integer_literal))))))

==================
Optional and result wrappers
==================

wrap :: @ value: i32 -> i32 ! str { ok value }
first :: @ items: []i32 -> i32? {
    match items {
        [] => nil
        [head, ...rest] => some head
    }
}
unwrap :: @ result: i32 ! str -> i32 {
    match result {
        ok value => value
        err _ => 0
    }
}

---

(source_file
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier)
        (primitive_type))
      (result_type
        (primitive_type)
        (primitive_type))
      (block
        (unary_expression
          (identifier)))))
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier)
        (array_type
          (primitive_type)))
      (optional_type
        (primitive_type))
      (block
        (match_expression
          (identifier)
          (match_arm
            (pattern
              (array_pattern))
            (nil_literal))
          (match_arm
            (pattern
              (array_pattern
                (array_pattern_entry
                  (pattern
                    (identifier)))
                (array_pattern_entry
                  (identifier))))
            (unary_expression
              (identifier)))))))
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier)
        (result_type
          (primitive_type)
          (primitive_type)))
      (primitive_type)
      (block
        (match_expression
          (identifier)
          (match_arm
            (pattern
              (wrapper_pattern
                (identifier)))
            (identifier))
          (match_arm
            (pattern
              (wrapper_pattern))
            (signed_numeric_literal
              (integer_literal))))))))

==================
Untyped function inputs
==================

double :: @ value { value * 2 }
sum: (i32, i32) -> i32: @ (left, right) { left + right }
mixed :: @ (left: i32, right) -> i32 { left + right }

---

(source_file
  (declaration
    (identifier)
    (function_literal
      (typed_parameter
        (identifier))
      (block
        (binary_expression
          (identifier)
          (signed_numeric_literal
            (integer_literal))))))
  (declaration
    (identifier)
    (function_type
      (tuple_type
        (primitive_type)
        (primitive_type))
      (primitive_type))
    (function_literal
      (typed_parameter
        (tuple_pattern
          (pattern
            (identifier))
          (pattern
            (identifier))))
      (block
        (binary_expression
          (identifier)
          (identifier)))))
  (declaration
    (identifier)
    (function_literal
      (typed_tuple_pattern
        (typed_tuple_component
          (identifier)
          (primitive_type))
        (typed_tuple_component
          (identifier)))
      (primitive_type)
      (block
        (binary_expression
          (identifier)
          (identifier))))))