Files
tree-sitter-lscript/test/corpus/basics.txt
T
paulandClaude Sonnet 5.5 61ea7166e3 Support some, ok and err wrappers and untyped function inputs
Track the LScript changes since the grammar was first written:

- some, ok and err are reserved prefix operators and wrapper patterns;
  the old |.some/|.ok/|.err forms and postfix/prefix ! are rejected
- function literal inputs may omit their type annotation, and tuple
  components may omit theirs; an empty typed tuple pattern is now just
  the unit pattern
- migrate fixtures, corpus, queries, CST contract and Rust tests

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-18 14:54:48 -04:00

436 lines
9.0 KiB
Plaintext

==================
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))))))