Grammar railroad diagram

[mingodad]

Asking gemini to extract an EBNF to generate a nice navigable railroad diagram gave me this one shown bellow with instructions at the top, I hope it can be a starting point to help document/develop/debug the grammar.

//
// EBNF to be viewd at https://www.bottlecaps.de/rr/ui
//
// Copy and paste this at one of the urls shown above in the 'Edit Grammar' tab
// then click the 'View Diagram' tab.
//
/* Top level entry point */
Program          ::= (GlobalDeclaration | Statement)*

GlobalDeclaration ::= FunctionDef 
                    | StructDef 
                    | EnumDef 
                    | TraitDef 
                    | ImplDef 
                    | IncludeStmt 
                    | ImportStmt 
                    | ComptimeBlock 
                    | TestBlock

/* Statements */
Statement        ::= Block
                   | IfStmt
                   | WhileStmt
                   | ForStmt
                   | LoopStmt
                   | RepeatStmt
                   | UnlessStmt
                   | GuardStmt
                   | MatchStmt
                   | ReturnStmt
                   | VarDecl
                   | ConstDecl
                   | TypeAlias
                   | AssertStmt
                   | DeferStmt
                   | AsmStmt
                   | PluginStmt
                   | Expression ";"

Block            ::= "{" Statement* "}"

IfStmt           ::= "if" Expression Block ("else" (IfStmt | Block))?
WhileStmt        ::= "while" Expression Block
ForStmt          ::= "for" "(" (VarDecl | Expression)? ";" Expression? ";" Expression? ")" Block
LoopStmt         ::= "loop" Block
RepeatStmt       ::= "repeat" Block "while" Expression ";"
UnlessStmt       ::= "unless" Expression Block
GuardStmt        ::= "guard" Expression "else" Block
ReturnStmt       ::= "return" Expression? ";"

MatchStmt        ::= "match" Expression "{" MatchArm* "}"
MatchArm         ::= Expression "=>" (Statement | Block)

/* Declarations */
VarDecl          ::= "var" Identifier (":" Type)? ("=" Expression)? ";"
ConstDecl        ::= "const" Identifier (":" Type)? "=" Expression ";"
TypeAlias        ::= "type" Identifier "=" Type ";"

FunctionDef      ::= "async"? "fn" Identifier "(" ParameterList? ")" ("->" Type)? Block
ParameterList    ::= Parameter ("," Parameter)*
Parameter        ::= Identifier ":" Type ("=" Expression)?

StructDef        ::= ("struct" | "union") Identifier "{" Field* "}"
Field            ::= Identifier ":" Type ";"

EnumDef          ::= "enum" Identifier "{" EnumVariant* "}"
EnumVariant      ::= Identifier ("=" Expression)? ("," | ";")?

TraitDef         ::= "trait" Identifier "{" FunctionDef* "}"
ImplDef          ::= ("impl" Identifier "for")? Identifier "{" FunctionDef* "}"

/* Expressions (simplified precedence levels) */
Expression       ::= Assignment
Assignment       ::= Ternary (("=" | "+=" | "-=" | "*=" | "/=") Assignment)?
Ternary          ::= Or ("?" Expression ":" Expression)?
Or               ::= And ("||" Or)?
And              ::= Equality ("&&" And)?
Equality         ::= Comparison (("==" | "!=") Equality)?
Comparison       ::= Term (("<" | ">" | "<=" | ">=") Comparison)?
Term             ::= Factor (("+" | "-") Term)?
Factor           ::= Unary (("*" | "/" | "%") Factor)?
Unary            ::= ("!" | "-" | "~" | "*" | "&")? Call
Call             ::= Primary ( "(" ArgumentList? ")" | "." Identifier | "[" Expression "]" )*

Primary          ::= Identifier 
                   | Literal 
                   | "(" Expression ")" 
                   | ArrayLiteral 
                   | TupleLiteral 
                   | Lambda 
                   | MacroCall 
                   | EmbedStmt

Literal          ::= Integer | Float | String | "true" | "false" | "null"
ArgumentList     ::= Expression ("," Expression)*
ArrayLiteral     ::= "[" (Expression ("," Expression)*)? "]"
TupleLiteral     ::= "(" Expression "," (Expression ("," Expression)*)? ")"

Lambda           ::= ("|" ParameterList? "|" | "fn" "(" ParameterList? ")") ("->" Type)? (Expression | Block)
MacroCall        ::= Identifier "!" "(" ArgumentList? ")"
EmbedStmt        ::= "embed" "(" String ")"

/* Types */
Type             ::= ("*" | "[]")* (Identifier | "void" | "int" | "float" | "bool" | "string")

/* Miscellaneous */
IncludeStmt      ::= "include" (String | "<" Identifier ">")
ImportStmt       ::= "import" String ("as" Identifier)?
AssertStmt       ::= "assert" Expression ("," String)? ";"
DeferStmt        ::= "defer" Statement
AsmStmt          ::= "asm" "{" String* "}"
PluginStmt       ::= "plugin" Identifier (Block | ";")
ComptimeBlock    ::= "comptime" Block
TestBlock        ::= "test" String? Block

[Zuhaitz-dev]

I am going to sleep now, but this looks interesting, I will check it tomorrow!

[ullenboom]

Funny, I did the same, because if we have a grammar, we can feed it into an LLM and start porting programs and writing test cases. Here is another draft:

(*
  Consolidated EBNF derived from the actual parser implementation.

  Conventions:
    X = ... ;     rule
    [ ... ]       optional
    { ... }       repetition (0..n)
    ( ... )       grouping
    "tok"         literal token
*)

(* =========================
   Lexical elements
   ========================= *)

Letter        = "A"…"Z" | "a"…"z" | "_" ;
Digit         = "0"…"9" ;

Identifier    = Letter { Letter | Digit } ;

IntLiteral    = Digit { Digit } ;
FloatLiteral  = Digit { Digit } "." Digit { Digit }
                [ ("e"|"E") ["+"|"-"] Digit { Digit } ] ;
CharLiteral   = "'" ( ? any char except ' and \ ? | "\\" escape ) "'" ;
StringLiteral = "\"" { ? any char except " and \ ? | "\\" escape } "\"" ;
FStringLiteral = "f" StringLiteral ;

BoolLiteral   = "true" | "false" ;

Literal       = IntLiteral | FloatLiteral | CharLiteral
              | StringLiteral | FStringLiteral | BoolLiteral ;

(* =========================
   Program structure
   ========================= *)

Program       = { TopItem } EOF ;

TopItem       = { Attribute } ( TopDecl | Statement ) ;

Attribute     = "@" Identifier
                [ "(" [ AttrArg { "," AttrArg } ] ")" ] ;
AttrArg       = Identifier | IntLiteral | StringLiteral ;

(* =========================
   Top-level declarations
   ========================= *)

TopDecl       = FunctionDef
              | StructDef
              | UnionDef
              | EnumDef
              | TraitDef
              | ImplDef
              | TypeAliasDecl
              | ImportStmt
              | PluginImportStmt
              | IncludeStmt
              | GlobalVarDecl
              | GlobalConstDecl
              | TestBlock
              | ComptimeBlock
              | RawTopBlock
              ;

RawTopBlock   = "raw" Block ;

FunctionDef   = [ "extern" ] [ "async" ] [ "inline" ]
                "fn" Identifier ParamList
                [ "->" Type ] Block ;

ParamList     = "(" [ Param { "," Param } ] ")" ;
Param         = [ "mut" ] Identifier ":" Type
                [ "=" Expression ] ;

StructDef     = "struct" Identifier [ GenericParams ] StructBody ;
UnionDef      = "union"  Identifier [ GenericParams ] StructBody ;

StructBody    = "{" { StructMember } "}" ;
StructMember  = FieldDecl Terminator
              | StructUse Terminator ;

StructUse     = "use" Type ;
FieldDecl     = Identifier ":" Type [ "=" ConstExpr ] ;

EnumDef       = "enum" Identifier [ GenericParams ]
                "{" { EnumVariant Terminator } "}" ;

EnumVariant   = Identifier
              | Identifier "(" [ Type { "," Type } ] ")"
              | Identifier "{" { FieldDecl TerminatorOrComma } "}"
              | Identifier "=" ConstExpr ;

TraitDef      = "trait" Identifier [ GenericParams ]
                "{" { TraitMember } "}" ;

TraitMember   = FunctionSig Terminator ;

FunctionSig   = [ "async" ] "fn" Identifier
                ParamList [ "->" Type ] ;

ImplDef       = "impl"
                ( ( Identifier "for" Type ) | Type )
                "{" { FunctionDef | FunctionSig Terminator } "}" ;

TypeAliasDecl = "type" Identifier "=" Type Terminator ;

GlobalVarDecl   = VarDecl ;
GlobalConstDecl = ConstDecl ;

GenericParams = "<" Identifier { "," Identifier } ">" ;

(* =========================
   Statements
   ========================= *)

Statement    = ";"
             | Block
             | IfStmt
             | WhileStmt
             | ForStmt
             | LoopStmt
             | RepeatStmt
             | UnlessStmt
             | GuardStmt
             | MatchStmt
             | ReturnStmt
             | BreakStmt
             | ContinueStmt
             | VarDecl
             | ConstDecl
             | AssertStmt
             | DeferStmt
             | AsmStmt
             | PluginStmt
             | RawStmt
             | PrintSugarStmt
             | ExprStmt
             ;

Block        = "{" { Statement } "}" ;

IfStmt       = "if" Expression Block
               [ "else" ( IfStmt | Block ) ] ;

UnlessStmt   = "unless" Expression Block ;

GuardStmt    = "guard" Expression "else"
               ( Block | Statement ) ;

LoopStmt     = "loop" Block ;
WhileStmt    = "while" Expression Block ;

ForStmt      = "for" ( ForRange | ForCStyle ) ;

ForRange     = Identifier "in"
               Expression ".." Expression
               [ "step" IntLiteral ] Block ;

ForCStyle    = "(" [ ForInit ] ";"
                   [ Expression ] ";"
                   [ Expression ] ")"
               Block ;

ForInit      = VarDeclNoSemi | Expression ;
VarDeclNoSemi = "var" [ "mut" ] VarPattern
                [ ":" Type ] [ "=" Expression ] ;

RepeatStmt   = "repeat" Expression Block ;

MatchStmt    = "match" Expression
               "{" { MatchArm } "}" ;

MatchArm     = PatternList [ MatchGuard ]
               "=>" MatchBody [ "," ] ;

PatternList  = Pattern { "," Pattern } ;
MatchGuard   = "if" Expression ;
MatchBody    = Block | Statement | Expression ;

Pattern      = "_"
             | Literal
             | PathIdent
             | PathIdent "(" Identifier ")" ;

PathIdent    = Identifier { "::" Identifier } ;

ReturnStmt   = "return" [ Expression ] ";" ;
BreakStmt    = "break" ";" ;
ContinueStmt = "continue" ";" ;

VarDecl      = "var" [ "mut" ] VarPattern
               [ ":" Type ] [ "=" Expression ] ";" ;

ConstDecl    = "const" Identifier
               [ ":" Type ] "=" Expression ";" ;

VarPattern   = Identifier
             | "(" Identifier { "," Identifier } ")"
             | "{" Identifier { "," Identifier } "}"
             | Identifier "{" FieldPattern { "," FieldPattern } "}"
             | PathIdent "(" Identifier ")" "else" Block ;

FieldPattern = Identifier [ ":" Identifier ] ;

AssertStmt   = "assert"
               "(" Expression [ "," StringLiteral ] ")" ";" ;

DeferStmt    = "defer" ( Block | Statement ) ;
AsmStmt      = "asm" Block ;
PluginStmt   = "plugin" Identifier ( Block | ";" ) ;

RawStmt      = "raw" Block ;

PrintSugarStmt =
               ( StringLiteral | FStringLiteral )
               ( ";" | ".." [ ";" ] ) ;

ExprStmt     = Expression ";" ;

TestBlock     = "test" [ StringLiteral ] Block ;
ComptimeBlock = "comptime" Block ;

(* =========================
   Expressions
   ========================= *)

Expression   = Assignment ;

Assignment   = Ternary
               [ AssignOp Assignment ] ;

AssignOp     = "=" | "+=" | "-=" | "*=" | "/=" | "%="
             | "|=" | "&=" | "^=" | "<<=" | ">>="
             | "??=" ;

Ternary      = Coalesce
               [ "?" Expression ":" Expression ] ;

Coalesce     = Or { "??" Or } ;

Or           = And { ( "||" | "or" ) And } ;
And          = Equality { ( "&&" | "and" ) Equality } ;

Equality     = Comparison { ( "==" | "!=" ) Comparison } ;
Comparison   = Shift { ( "<" | "<=" | ">" | ">=" ) Shift } ;
Shift        = BitTerm { ( "<<" | ">>" ) BitTerm } ;

BitTerm      = Add { ( "|" | "^" | "&" ) Add } ;
Add          = Mul { ( "+" | "-" ) Mul } ;
Mul          = Pipe { ( "*" | "/" | "%" ) Pipe } ;
Pipe         = Unary { "|>" Unary } ;

Unary        = ( "await" | "!" | "~" | "-" | "+" | "*" | "&" ) Unary
             | Postfix ;

Postfix      = Primary { PostfixOp } ;

PostfixOp    = CallArgs
             | Index
             | Member
             | OptMember
             | UnwrapQ ;

CallArgs     = "(" [ Expression { "," Expression } ] ")" ;
Index        = "[" Expression "]" ;
Member       = "." Identifier ;
OptMember    = "?." Identifier ;
UnwrapQ      = "?" ;

Primary      = Literal
             | Identifier
             | "(" Expression ")"
             | ArrayLiteral
             | TupleLiteral
             | Lambda
             | MatchExpr
             | PromptExpr
             | MacroCall ;

ArrayLiteral = "[" [ Expression { "," Expression } ] "]" ;
TupleLiteral = "(" Expression "," [ Expression { "," Expression } ] ")" ;

Lambda       = "fn" ParamList [ "->" Type ]
               ( Block | Expression ) ;

MatchExpr    = "match" Expression
               "{" { MatchArm } "}" ;

PromptExpr   = "?" ( StringLiteral | FStringLiteral )
               [ "(" [ Expression { "," Expression } ] ")" ] ;

MacroCall    = Identifier "!"
               ( "(" [ Expression { "," Expression } ] ")" | Block ) ;

ConstExpr    = Expression ;

(* =========================
   Types
   ========================= *)

Type         = [ "restrict" ]
               ( FunctionType | ArrayType | NamedType ) ;

FunctionType = "fn" "(" [ Type { "," Type } ] ")"
               [ "->" Type ] ;

ArrayType    = "[" Type [ ";" ConstExpr ] "]" ;

NamedType    = [ "struct" | "enum" ]
               PathIdent [ GenericArgs ] ;

GenericArgs  = "<" Type { "," Type } ">" ;

EOF          = ? end of input ? ;

[mingodad]

Hello @ullenboom from your previous message I manually modified it to be able to generate a navigable railroad diagram.

//
// EBNF to be viewd at https://www.bottlecaps.de/rr/ui
//
// Copy and paste this at one of the urls shown above in the 'Edit Grammar' tab
// then click the 'View Diagram' tab.
//

Program          ::= TopLevelDecl* EOF 

TopLevelDecl     ::= AttributeList? ( FunctionDef
                 | StructDef | UnionDef | EnumDef
                 | ImplDef | TraitDef
                 | VarDecl | ConstDecl | TypeAliasDecl
                 | ImportStmt | IncludeStmt | PluginImportStmt
                 | MacroDef
                 | RawBlock ) 

FunctionDef      ::= "fn" Identifier FunctionParams ( "->" Type )? Block 
FunctionParams   ::= "(" ( ParamDecl ( "," ParamDecl )* )? ")" 
ParamDecl        ::= "mut"? Identifier ":" Type 

StructDef        ::= "struct" Identifier GenericParams? StructBody 
UnionDef         ::= "union"  Identifier GenericParams? StructBody 
StructBody       ::= "{" ( FieldDecl (";" | ",")? )* "}" 
FieldDecl        ::= Identifier ":" Type ( "=" ConstExpr )?

EnumDef          ::= "enum" Identifier GenericParams? EnumBody 
EnumBody         ::= "{" ( EnumVariant (";" | ",")? )* "}" 
EnumVariant      ::= Identifier
                 | Identifier "(" ( Type ( "," Type )* )? ")"
                 | Identifier "{" ( FieldDecl ","? )* "}"
                 | Identifier "=" ConstExpr 

TraitDef         ::= "trait" Identifier GenericParams? "{" TraitMember* "}" 
TraitMember      ::= FunctionDefSignature ";"
                 | /* other possible members: consts, types, ... */ 

ImplDef          ::= "impl" GenericParams? ( Identifier "for" )? Type
                   "{" ( FunctionDef | /* etc */ )* "}" 

ImportStmt       ::= "import" ImportTail 
ImportTail       ::= ImportSelective | ImportModule 
ImportModule     ::= StringLiteral ( "as" Identifier )? ";" 
ImportSelective  ::= "{" Identifier ( "as" Identifier )?
                   ( "," Identifier ( "as" Identifier )? )* "}"
                   "from" StringLiteral ( "as" Identifier )? ";" 
PluginImportStmt ::= "import" "plugin" StringLiteral ( "as" Identifier )? ";" 

IncludeStmt      ::= "include" ( "<" Filename ">" | StringLiteral ) ";" 

RawBlock         ::= "raw" "{" any_source_text "}" 

AttributeList    ::= Attribute Attribute* 
Attribute        ::= "@" Identifier ( "(" ( AttributeArg ( "," AttributeArg )* )? ")" )?
AttributeArg     ::= IntLiteral | StringLiteral | Identifier 

GenericParams    ::= "<" Identifier ( "," Identifier )* ">" 

/*Types*/

Type            ::= FunctionType | TypeFormal 

FunctionType    ::= "fn" "(" ( TypeFormal ( "," TypeFormal )* )? ")" ( "->" TypeFormal )? 

TypeFormal      ::= "restrict"? TypeBase "*"* ArraySuffix*

TypeBase        ::= ( "struct" | "enum" )? Identifier ( "::" Identifier )* GenericArgs?
                | "(" TypeFormal ")"        // parenthesized type
                | TupleType
                | "Self" 

TupleType       ::= "(" TypeFormal "," TypeFormal ( "," TypeFormal )* ")" 

GenericArgs     ::= "<" TypeFormal ( ( "," TypeFormal )* )? ">" 

ArraySuffix     ::= "[" ConstExpr? "]"
                | "[" TypeFormal ";" ConstExpr "]" 


/* Statements */

Statement       ::= Block
                | IfStmt | UnlessStmt | GuardStmt
                | LoopStmt | WhileStmt | RepeatStmt | ForStmt
                | MatchStmt
                | DeferStmt | AsmStmt
                | BreakStmt | ContinueStmt | ReturnStmt | AssertStmt
                | VarDecl | ConstDecl | TypeAliasDecl
                | ExprStmt 

Block           ::= "{" Statement* "}" 

IfStmt          ::= "if" "(" Expression ")" Block ( "else" ( Block | IfStmt ) )?
UnlessStmt      ::= "unless" "(" Expression ")" Block 
GuardStmt       ::= "guard" "(" Expression ")" "else" ( Block | Statement ) 

LoopStmt        ::= "loop" Block 
WhileStmt       ::= "while" "(" Expression ")" Block 
RepeatStmt      ::= "repeat" Block "until" "(" Expression ")" ";" 

ForStmt         ::= "for" ( ForRange | CStyleFor ) 
ForRange        ::= Identifier "in" Expression ".." Expression ( "step" IntLiteral )? Block 
CStyleFor       ::= "("? ForInit? ";" Expression? ";" Expression? ")"? Block 
ForInit         ::= VarDecl | ExprStmt 

BreakStmt       ::= "break" ";" 
ContinueStmt    ::= "continue" ";" 
ReturnStmt      ::= "return" Expression? ";" 
AssertStmt      ::= "assert" "(" Expression ")" ";" 
DeferStmt       ::= "defer" ( Block | Statement ) 
AsmStmt         ::= "asm" Block 

VarDecl         ::= "var" "mut"? VarPattern ( ":" Type )? ( "=" Expression )? ";" 
ConstDecl       ::= "const" Identifier ( ":" Type )? "=" Expression ";" 
TypeAliasDecl   ::= "type" Identifier "=" Type ";" 

VarPattern      ::= Identifier
                | "(" Identifier ( "," Identifier )* ")"
                | Identifier "{" FieldPatternList "}"
                | "{" Identifier ( "," Identifier )* "}"
                | Identifier "(" Identifier ")" "else" Block
                

FieldPatternList ::= FieldPattern ( "," FieldPattern )* 
FieldPattern    ::= Identifier ( ":" Identifier )?

ExprStmt        ::= Expression ";" 
MatchStmt       ::= MatchExpr ";" 

/* Expressions */

Expression       ::= AssignmentExpr 

AssignmentExpr   ::= LogicOrExpr ( "=" AssignmentExpr
                   | "+=" AssignmentExpr | "-=" AssignmentExpr
                   | "*=" AssignmentExpr | "/=" AssignmentExpr
                   | "%=" AssignmentExpr | "&&=" AssignmentExpr | "||=" AssignmentExpr
                   | "&=" AssignmentExpr | "|=" AssignmentExpr | "^=" AssignmentExpr
                   | "<<=" AssignmentExpr | ">>=" AssignmentExpr
                   | "??=" AssignmentExpr )?

LogicOrExpr      ::= LogicAndExpr ( ( "||" | "or" ) LogicAndExpr )*
LogicAndExpr     ::= BitOrExpr   ( ( "&&" | "and" ) BitOrExpr   )* 

BitOrExpr        ::= BitXorExpr  ( "|" BitXorExpr )*
BitXorExpr       ::= BitAndExpr  ( "^" BitAndExpr )* 
BitAndExpr       ::= EqualityExpr ( "&" EqualityExpr )* 

EqualityExpr     ::= RelationalExpr ( ( "==" | "!=" ) RelationalExpr )* 
RelationalExpr   ::= ShiftExpr      ( ( "<" | "<=" | ">" | ">=" ) ShiftExpr )* 

ShiftExpr        ::= AddExpr ( ( "<<" | ">>" ) AddExpr )* 
AddExpr          ::= Term    ( ( "+" | "-" ) Term )* 
Term             ::= Factor  ( ( "*" | "/" | "%" ) Factor )* 

Factor           ::= UnaryExpr    // Alias nonterminal for clarity

UnaryExpr        ::= ( "-" | "+" | "!" | "~" | "await" )? PrimaryExpr
                 | "sizeof" "(" ( Type | Expression ) ")"
                 | "typeof" "(" ( Type | Expression ) ")" 

PrimaryExpr      ::= Literal
                 | Identifier
                 | "(" Expression ")"
                 | LambdaExpr
                 | PrimaryExpr Selector
                 | PrimaryExpr Arguments
                 | PrimaryExpr Index
                 | MatchExpr 

Selector         ::= "." Identifier | "?." Identifier 
Arguments        ::= "(" ( Expression ( "," Expression )* )? ")" 
Index            ::= "[" Expression "]" 

LambdaExpr       ::= "fn" LambdaParams LambdaBody
                 | Identifier "=>" Expression    // short lambda: one parameter

LambdaParams     ::= "(" ( ParamDecl ( "," ParamDecl )* )? ")" 
LambdaBody       ::= Block | "->" Expression       // body can be a block or an expression

Literal          ::= IntLiteral | FloatLiteral | CharLiteral | StringLiteral | FStringLiteral | BoolLiteral
                 | "None" | "NULL" 

MatchExpr        ::= "match" Expression "{" ( MatchArm ","? )* "}" 
MatchArm         ::= Pattern Guard? "=>" ( Expression | Block ) 
Pattern          ::= "_"
                 | Literal
                 | Identifier ( "(" Identifier ")" )?   // variant with optional binding
Guard            ::= "if" Expression 

/* Tokens */

Letter        ::= [A–Za–z_] 
Digit         ::= [0–9] 
Identifier    ::= Letter ( Letter | Digit )* 

IntLiteral    ::= Digit+ 
FloatLiteral  ::= Digit+ "." Digit+
               ( ( "e" | "E" ) ("+" | "-" )? Digit+ )? 
CharLiteral   ::= "'" ( [^'] | "'" | "\\" ) "'" 
StringLiteral ::= '"' ( [^"] | '\"' | "\\" )* '"' 
FStringLiteral ::= "f" StringLiteral 

BoolLiteral   ::= "true" | "false" 

Operator ::= "?" | "?." | "??" | "??=" | "->" | "=>" | "::" | ".." | "..."
         | "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">="
         | "&&" | "||" | "and" | "or" | "!" | "|" | "&" | "^" | "<<" | ">>" | "|>" 

Separator ::= "(" | ")" | "{" | "}" | "[" | "]" | "," | ":" | ";" | "@" 

[ullenboom]

A typecast is somehow unique; it's not a unary operator.