Grammar railroad diagram

[mingodad]

Using https://mingodad.github.io/plgh/json2ebnf.html with https://raw.githubusercontent.com/gleam-lang/tree-sitter-gleam/main/src/grammar.json we can have a nice navigable railroad diagram to help document/develop/debug gleam see instructions bellow:

//
// EBNF to generate railroad diagram at
//      (IPV6) https://www.bottlecaps.de/rr/ui
//      (IPV4) https://rr.red-dove.com/ui
//
// From https://raw.githubusercontent.com/gleam-lang/tree-sitter-gleam/main/src/grammar.json
//

source_file ::=
	 ( target_group | _module_statement | _statement_seq )*

_module_statement ::=
	 import
	| constant
	| external_type
	| external_function
	| function
	| type_definition
	| type_alias
	| attribute

module_comment ::=
	 ( '////' '.'* )

statement_comment ::=
	 ( '///' '.'* )

comment ::=
	 ( '//' '.'* )

target_group ::=
	 'if' target '{' _module_statement* '}'

target ::=
	 'erlang'
	| 'javascript'

attribute ::=
	 '@' identifier _attribute_arguments?

_attribute_arguments ::=
	 '(' attribute_value ( ',' attribute_value )* ','? ')'

attribute_value ::=
	 _constant_value
	| label ':' _constant_value

import ::=
	 'import' module ( '.' unqualified_imports )? ( 'as' ( identifier | discard ) )?

module ::=
	 _name ( '/' _name )*

unqualified_imports ::=
	 '{' ( unqualified_import ( ',' unqualified_import )* ','? )? '}'

unqualified_import ::=
	 identifier ( 'as' identifier )?
	| 'type'? type_identifier ( 'as' type_identifier )?

constant ::=
	 visibility_modifier? 'const' identifier _constant_type_annotation? '=' _constant_value

_constant_value ::=
	 string
	| float
	| integer
	| constant_tuple
	| constant_list
	| _constant_bit_string
	| constant_record
	| identifier
	| constant_field_access

constant_tuple ::=
	 '#' '(' ( _constant_value ( ',' _constant_value )* ','? )? ')'

constant_list ::=
	 '[' ( _constant_value ( ',' _constant_value )* ','? )? ']'

_constant_bit_string ::=
	 '<<' ( constant_bit_string_segment ( ',' constant_bit_string_segment )* ','? )? '>>'

constant_bit_string_segment ::=
	 _constant_value ( ':' constant_bit_string_segment_options )?

constant_bit_string_segment_options ::=
	 _constant_bit_string_segment_option ( '-' _constant_bit_string_segment_option )* '-'?

_constant_bit_string_segment_option ::=
	 _constant_bit_string_named_segment_option
	| integer

_constant_bit_string_named_segment_option ::=
	 ( _bit_string_segment_option | _constant_bit_string_segment_option_size )

_constant_bit_string_segment_option_size ::=
	 'size' '(' integer ')'

constant_record ::=
	 ( constructor_name | remote_constructor_name ) constant_record_arguments?

constant_record_arguments ::=
	 '(' ( constant_record_argument ( ',' constant_record_argument )* ','? )? ')'

constant_record_argument ::=
	 ( label ':' )? _constant_value

constant_field_access ::=
	 identifier '.' label

_constant_type ::=
	 type_hole
	| constant_tuple_type
	| constant_function_type
	| constant_type

_constant_type_annotation ::=
	 ':' _constant_type

constant_tuple_type ::=
	 '#' '(' ( _constant_type ( ',' _constant_type )* ','? )? ')'

constant_function_type ::=
	 'fn' constant_function_parameter_types? '->' _constant_type

constant_function_parameter_types ::=
	 '(' ( _constant_type ( ',' _constant_type )* ','? )? ')'

constant_type ::=
	 ( type_identifier | remote_type_identifier ) constant_type_arguments?

constant_type_arguments ::=
	 '(' ( constant_type_argument ( ',' constant_type_argument )* ','? )? ')'

constant_type_argument ::=
	 _constant_type

external_type ::=
	 visibility_modifier? 'external'? 'type' type_name

external_function ::=
	 visibility_modifier? 'external' 'fn' identifier external_function_parameters '->' _type '=' external_function_body

external_function_parameters ::=
	 '(' ( external_function_parameter ( ',' external_function_parameter )* ','? )? ')'

external_function_parameter ::=
	 ( identifier ':' )? _type

external_function_body ::=
	 string string

function ::=
	 visibility_modifier? 'fn' identifier function_parameters ( '->' _type )? ( '{' _statement_seq? '}' )?

function_parameters ::=
	 '(' ( function_parameter ( ',' function_parameter )* ','? )? ')'

function_parameter ::=
	 ( _labeled_discard_param | _discard_param | _labeled_name_param | _name_param ) _type_annotation?

_labeled_discard_param ::=
	 label discard

_discard_param ::=
	 discard

_labeled_name_param ::=
	 label identifier

_name_param ::=
	 identifier

_statement_seq ::=
	 _statement+

_statement ::=
	 _expression
	| let
	| let_assert
	| use

_expression ::=
	 _expression_unit
	| binary_expression

binary_expression ::=
	 _expression '||' _expression
	| _expression '&&' _expression
	| _expression '==' _expression
	| _expression '!=' _expression
	| _expression '<' _expression
	| _expression '<=' _expression
	| _expression '<.' _expression
	| _expression '<=.' _expression
	| _expression '>' _expression
	| _expression '>=' _expression
	| _expression '>.' _expression
	| _expression '>=.' _expression
	| _expression '|>' _expression
	| _expression '+' _expression
	| _expression '+.' _expression
	| _expression '-' _expression
	| _expression '-.' _expression
	| _expression '*' _expression
	| _expression '*.' _expression
	| _expression '/' _expression
	| _expression '/.' _expression
	| _expression '%' _expression
	| _expression '<>' _expression

_expression_unit ::=
	 string
	| integer
	| float
	| record
	| identifier
	| todo
	| panic
	| tuple
	| list
	| _expression_bit_string
	| anonymous_function
	| block
	| case
	| assert
	| boolean_negation
	| integer_negation
	| record_update
	| tuple_access
	| field_access
	| function_call

record ::=
	 ( constructor_name | remote_constructor_name ) arguments?

todo ::=
	 'todo' ( '(' string ')' | 'as' _expression )?

panic ::=
	 'panic' ( '(' string ')' | 'as' _expression )?

tuple ::=
	 '#' '(' ( _expression ( ',' _expression )* ','? )? ')'

list ::=
	 '[' ( _expression ( ',' _expression )*? ','? ( '..' _expression )? )? ']'

_expression_bit_string ::=
	 '<<' ( expression_bit_string_segment ( ',' expression_bit_string_segment )* ','? )? '>>'

expression_bit_string_segment ::=
	 _expression_unit ( ':' expression_bit_string_segment_options )?

expression_bit_string_segment_options ::=
	 _expression_bit_string_segment_option ( '-' _expression_bit_string_segment_option )* '-'?

_expression_bit_string_segment_option ::=
	 _expression_bit_string_named_segment_option
	| integer

_expression_bit_string_named_segment_option ::=
	 ( _bit_string_segment_option | _expression_bit_string_segment_option_size )

_expression_bit_string_segment_option_size ::=
	 'size' '(' _expression ')'

anonymous_function ::=
	 'fn' anonymous_function_parameters ( '->' _type )? '{' _statement_seq '}'

anonymous_function_parameters ::=
	 '(' ( anonymous_function_parameter ( ',' anonymous_function_parameter )* ','? )? ')'

anonymous_function_parameter ::=
	 ( _discard_param | _name_param ) _type_annotation?

block ::=
	 '{' _statement_seq '}'

case ::=
	 'case' case_subjects '{' case_clauses? '}'

case_subjects ::=
	 _expression ( ',' _expression )* ','?

case_clauses ::=
	 case_clause+

case_clause ::=
	 case_clause_patterns case_clause_guard? '->' _expression

case_clause_patterns ::=
	 case_clause_pattern ( '|' case_clause_pattern )* '|'?

case_clause_pattern ::=
	 _pattern ( ',' _pattern )* ','?

case_clause_guard ::=
	 'if' _case_clause_guard_expression

_case_clause_guard_expression ::=
	 _case_clause_guard_unit
	| _case_clause_guard_binary_expression
	| boolean_negation

_case_clause_guard_binary_expression ::=
	 _case_clause_guard_expression '||' _case_clause_guard_expression
	| _case_clause_guard_expression '&&' _case_clause_guard_expression
	| _case_clause_guard_expression '==' _case_clause_guard_expression
	| _case_clause_guard_expression '!=' _case_clause_guard_expression
	| _case_clause_guard_expression '<' _case_clause_guard_expression
	| _case_clause_guard_expression '<=' _case_clause_guard_expression
	| _case_clause_guard_expression '<.' _case_clause_guard_expression
	| _case_clause_guard_expression '<=.' _case_clause_guard_expression
	| _case_clause_guard_expression '>' _case_clause_guard_expression
	| _case_clause_guard_expression '>=' _case_clause_guard_expression
	| _case_clause_guard_expression '>.' _case_clause_guard_expression
	| _case_clause_guard_expression '>=.' _case_clause_guard_expression

_case_clause_guard_unit ::=
	 identifier
	| _case_clause_tuple_access
	| '{' _case_clause_guard_expression '}'
	| _constant_value

_case_clause_tuple_access ::=
	 identifier '.' integer

let_assert ::=
	 'let' 'assert' _assignment

let ::=
	 'let' _assignment

use ::=
	 'use' use_assignments? '<-' _expression

use_assignments ::=
	 use_assignment ( ',' use_assignment )* ','?

use_assignment ::=
	 _pattern _type_annotation?

assert ::=
	 'assert' _assignment

boolean_negation ::=
	 '!' _expression_unit

integer_negation ::=
	 '-' _expression_unit

_assignment ::=
	 _pattern _type_annotation? '=' _expression

record_update ::=
	 ( constructor_name | remote_constructor_name ) '(' '..' _expression ',' record_update_arguments ')'

record_update_arguments ::=
	 record_update_argument ( ',' record_update_argument )* ','?

record_update_argument ::=
	 label ':' _expression

_maybe_tuple_expression ::=
	 identifier
	| function_call
	| tuple
	| block
	| case
	| field_access
	| tuple_access

tuple_access ::=
	 _maybe_tuple_expression '.' integer

_maybe_record_expression ::=
	 record
	| identifier
	| function_call
	| block
	| case
	| record_update
	| field_access
	| tuple_access

field_access ::=
	 _maybe_record_expression '.' label

_maybe_function_expression ::=
	 identifier
	| anonymous_function
	| block
	| case
	| tuple_access
	| field_access
	| function_call

arguments ::=
	 '(' ( argument ( ',' argument )* ','? )? ')'

argument ::=
	 ( label ':' )? ( hole | _expression )

hole ::=
	 _discard_name

function_call ::=
	 _maybe_function_expression arguments

_pattern_expression ::=
	 identifier
	| discard
	| record_pattern
	| string
	| integer
	| float
	| tuple_pattern
	| _pattern_bit_string
	| list_pattern
	| _pattern_binary_expression

_pattern_binary_expression ::=
	 _pattern_expression '<>' _pattern_expression
	| string 'as' identifier

_pattern ::=
	 _pattern_expression ( 'as' identifier )?

record_pattern ::=
	 ( constructor_name | remote_constructor_name ) record_pattern_arguments?

record_pattern_arguments ::=
	 '(' ( record_pattern_argument ( ',' record_pattern_argument )* ','? )? pattern_spread? ')'

record_pattern_argument ::=
	 ( label ':' )? _pattern

pattern_spread ::=
	 '..' ','?

tuple_pattern ::=
	 '#' '(' ( _pattern ( ',' _pattern )* ','? )? ')'

_pattern_bit_string ::=
	 '<<' ( pattern_bit_string_segment ( ',' pattern_bit_string_segment )* ','? )? '>>'

pattern_bit_string_segment ::=
	 _pattern ( ':' pattern_bit_string_segment_options )?

pattern_bit_string_segment_options ::=
	 _pattern_bit_string_segment_option ( '-' _pattern_bit_string_segment_option )* '-'?

_pattern_bit_string_segment_option ::=
	 _pattern_bit_string_named_segment_option
	| integer

_pattern_bit_string_named_segment_option ::=
	 ( _bit_string_segment_option | _pattern_bit_string_segment_option_size )

_pattern_bit_string_segment_option_size ::=
	 'size' '(' _pattern_bit_string_segment_argument ')'

_pattern_bit_string_segment_argument ::=
	 identifier
	| integer

list_pattern ::=
	 '[' ( _pattern ( ',' _pattern )* ','? )? list_pattern_tail? ']'

list_pattern_tail ::=
	 '..' ( identifier | discard )?

visibility_modifier ::=
	 'pub'

opacity_modifier ::=
	 'opaque'

type_definition ::=
	 visibility_modifier? opacity_modifier? 'type' type_name '{' data_constructors '}'

data_constructors ::=
	 data_constructor+

data_constructor ::=
	 constructor_name data_constructor_arguments?

data_constructor_arguments ::=
	 '(' ( data_constructor_argument ( ',' data_constructor_argument )* ','? )? ')'

data_constructor_argument ::=
	 ( label ':' )? _type

type_alias ::=
	 visibility_modifier? opacity_modifier? 'type' type_name '=' _type

string ::=
	 '"'  ( escape_sequence | quoted_content )* '"' 

escape_sequence ::=
	 '\'[efnrt\"\]
	| '\u\{'[0-9a-fA-F]'{1,6}\}'

float ::=
	 '-'?[0-9_]+'.'[0-9_]*('e-'?[0-9_]+)?

integer ::=
	 '-'? ( _hex | _decimal | _octal | _binary )

_hex ::=
	 '0'[xX][0-9a-fA-F_]+

_decimal ::=
	 [0-9][0-9_]*

_octal ::=
	 '0'[oO][0-7_]+

_binary ::=
	 '0'[bB][0-1_]+

_bit_string_segment_option ::=
	 'binary'
	| 'bytes'
	| 'int'
	| 'float'
	| 'bit_string'
	| 'bits'
	| 'utf8'
	| 'utf16'
	| 'utf32'
	| 'utf8_codepoint'
	| 'utf16_codepoint'
	| 'utf32_codepoint'
	| 'signed'
	| 'unsigned'
	| 'big'
	| 'little'
	| 'native'
	| 'unit' '(' integer ')'

_type ::=
	 type_hole
	| tuple_type
	| function_type
	| type
	| type_var

_type_annotation ::=
	 ':' _type

type_hole ::=
	 _discard_name

tuple_type ::=
	 '#' '(' ( _type ( ',' _type )* ','? )? ')'

function_type ::=
	 'fn' function_parameter_types? '->' _type

function_parameter_types ::=
	 '(' ( _type ( ',' _type )* ','? )? ')'

type ::=
	 ( type_identifier | remote_type_identifier ) type_arguments?

type_arguments ::=
	 '(' ( type_argument ( ',' type_argument )* ','? )? ')'

type_argument ::=
	 _type

type_var ::=
	 _name

type_name ::=
	 ( type_identifier | remote_type_identifier ) type_parameters?

type_parameters ::=
	 '(' ( type_parameter ( ',' type_parameter )* ','? )? ')'

type_parameter ::=
	 _name

identifier ::=
	 _name

label ::=
	 _name

discard ::=
	 _discard_name

type_identifier ::=
	 _upname

remote_type_identifier ::=
	 identifier '.' type_identifier

constructor_name ::=
	 _upname

remote_constructor_name ::=
	 identifier '.' constructor_name

_discard_name ::=
	 '_'[_0-9a-z]*

_name ::=
	 [_a-z][_0-9a-z]*

_upname ::=
	 [A-Z][0-9a-zA-Z]*

[lpil]

Hello! Sorry, what is this issue for? I'm not sure what you're suggesting

[ghost]

I think he propose a language grammar documentation, like these. I presume it good for language clarity, maybe, It's nice to have.