C# Class Lens.Parser.LensParser

accessor = accessor_idx | accessor_mbr

accessor_idx = "[" line_expr "]"

accessor_mbr = "." identifier [ type_args ]

atom = literal | get_id_expr | get_stmbr_expr | new_collection_expr | paren_expr

block = local_stmt_list | local_stmt

block_expr = if_block | while_block | for_block | using_block | try_stmt | match_block | new_block_expr | invoke_block_expr | invoke_block_pass_expr | lambda_block_expr

catch_stmt = "catch" [ identifier ":" type ] block

catch_stmt_list = catch_stmt { catch_stmt }

default_expr = "default" type

expr = block_expr | line_expr

finally_stmt = "finally" block

for_block = for_header block

for_block = "for" identifier "in" line_expr [ ".." line_expr ] "do"

for_line = for_header line_stmt

fun_args = fun_single_arg | fun_many_args

fun_def = [ "pure" ] "fun" identifier [ ":" type ] fun_args "->" block

fun_arg_list = "(" { fun_single_arg } ")"

fun_arg = identifier [ ":" [ "ref" ] type [ "... " ] ]

get_expr = atom { accessor }

get_id_expr = identifier [ type_args ]

get_stmbr_expr = type "::" identifier [ type_args ]

if_block = if_header block [ NL "else" block ]

if_header = "if" line_expr "then"

if_line = if_header line_stmt [ "else" line_stmt ]

init_dict_expr = line_expr "=>" line_expr

init_expr_block = INDENT line_expr { NL line_expr } DEDENT

init_expr_dict_block = INDENT init_dict_expr { NL init_dict_expr } DEDENT

init_expr_dict_line = init_dict_expr { ";" init_dict_expr }

init_expr_line = line_expr { ";" line_expr }

invoke_block_arg = "<|" ( ref_arg | expr )

invoke_block_args = INDENT invoke_block_arg { NL invoke_block_arg } DEDENT

invoke_block_expr = line_expr [ INDENT invoke_pass { NL invoke_pass } DEDENT ]

invoke_line_arg = ref_arg | get_expr

invoke_line_args = { invoke_line_arg }

invoke_pass = "|>" identifier [ type_args ] ( invoke_block_args | invoke_line_args )

lambda_block_expr = [ fun_args ] "->" block

lambda_line_expr = [ fun_args ] "->" line_expr

let_stmt = "let" identifier "=" expr

line_base_expr = line_invoke_base_expr | get_expr

line_expr = if_line | while_line | for_line | using_line | throw_stmt | new_object_line | typeop_expr | line_typecheck_expr

line_invoke_base_expr = get_expr [ invoke_line_args ]

line_op_expr = [ unary_op ] line_base_expr { binary_op line_base_expr }

line_stmt = set_stmt | line_expr

line_typecheck_expr = line_op_expr [ typecheck_op_expr ]

literal = unit | null | bool | int | long | float | double | decimal | char | string

local_stmt = name_def_stmt | set_stmt | expr

local_stmt_list = INDENT local_stmt { NL local_stmt } DEDENT

lvalue_expr = lvalue_name_expr | lvalue_paren_expr

lvalue_id_expr = identifier

lvalue_name = lvalue_stmbr_expr | lvalue_id_expr

lvalue_name_expr = lvalue_name { accessor }

lvalue_paren_expr = paren_expr accessor { accessor }

lvalue_stmbr_expr = type "::" identifier

main = stmt { NL stmt } EOF

match_block = "match" line_expr "with" INDENT { match_stmt } DEDENT

match_rule = rule_generic [ rule_keyvalue ]

match_rules = match_rule { [ NL ] "|" match_rule }

match_stmt = "case" match_rules [ "when" line_expr ] "then" block

name_def_stmt = var_stmt | let_stmt

namespace = identifier { "." identifier }

new_array_block = "[" init_expr_block "]"

new_array_line = "[" init_expr_block "]"

new_block_expr = "new" new_tuple_block | new_array_block | new_list_block | new_dict_block | new_object_block

new_collection_expr = "new" ( new_tuple_line | new_list_line | new_array_line | new_dict_line )

new_dict_block = "{" init_dict_expr_block "}"

new_dict_line = "{" init_dict_expr_block "}"

new_list_block = "[" "[" init_expr_block "]" "]"

new_list_line = "[" "[" init_expr_block "]" "]"

new_objarray_line = type "[" line_expr "]"

new_object_block = type invoke_block_args

new_line_expr = "new" ( new_objarray_line | new_object_block )

new_object_line = type invoke_line_args

new_tuple_block = "(" init_expr_block ")"

new_tuple_line = "(" init_expr_line ")"

paren_expr = "(" ( lambda_line_expr | line_expr ) ")"

record_def = "record" identifier INDENT record_stmt { NL record_stmt } DEDENT

record_stmt = identifier ":" type

ref_arg = "ref" lvalue_expr | "(" "ref" lvalue_expr ")"

rule_regex = regex

rule_array = "[" [ rule_array_item { ";" rule_array_item } ] "]"

rule_array_item = rule_subsequence | match_rule

rule_generic = rule_tuple | rule_array | rule_regex | rule_record | rule_type | rule_range | rule_literal | rule_name

rule_keyvalue = "=>" rule_generic

rule_literal = literal

rule_name = identifier [ ":" type ]

rule_range = rule_literal ".." rule_literal

rule_record = identifier "(" rule_record_var { ";" rule_record_var } ")"

rule_record_var = identifier "=" match_rule

rule_subsequence = "..." identifier

rule_tuple = "(" match_rule { ";" match_rule } ")"

rule_type = identifier "of" match_rule

set_any_stmt = lvalue_expr assignment_op expr

set_id_stmt = identifier assignment_op expr

set_stmbr_stmt = type "::" identifier assignment_op expr

set_stmt = set_id_stmt | set_stmbr_stmt | set_any_stmt

stmt = using | record_def | type_def | fun_def | local_stmt

throw_stmt = "throw" [ line_expr ]

try_stmt = "try" block catch_stmt_list [ finally_stmt ]

type = namespace [ type_args ] { "[]" | "?" | "~" }

type_args = "<" type { "," type } ">"

type_def = "type" identifier INDENT type_stmt { type_stmt } DEDENT

type_stmt = identifier [ "of" type ]

typecheck_op_expr = "as" type | "is" type

typeof_expr = "typeof" type

typeop_expr = default_expr | typeof_expr

using = "using" namespace NL

using_block = using_header block

using_header = "using" [ identifier "=" ] line_expr "do"

using_line = using_header line_stmt

var_stmt = "var" identifier ( "=" expr | ":" type )

while_block = while_header block

while_header = "while" line_expr "do"

while_line = while_header line_stmt