Appendix

Containers

A container in Zig is any syntactical construct that acts as a namespace to hold variable and function declarations. Containers are also type definitions which can be instantiated. Structs, enums, unions, opaques, and even Zig source files themselves are containers.

Although containers (except Zig source files) use curly braces to surround their definition, they should not be confused with blocks or functions. Containers do not contain statements.

Grammar

grammar.y

  1. Root <- skip container_doc_comment? ContainerMembers eof
  3. # *** Top level ***
  4. ContainerMembers <- ContainerDeclaration* (ContainerField COMMA)* (ContainerField / ContainerDeclaration*)
  6. ContainerDeclaration <- TestDecl / ComptimeDecl / doc_comment? KEYWORD_pub? Decl
  8. TestDecl <- KEYWORD_test (STRINGLITERALSINGLE / IDENTIFIER)? Block
  10. ComptimeDecl <- KEYWORD_comptime Block
  12. Decl
  13.     <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / KEYWORD_inline / KEYWORD_noinline)? FnProto (SEMICOLON / Block)
  14.      / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? GlobalVarDecl
  15.      / KEYWORD_usingnamespace Expr SEMICOLON
  17. FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? AddrSpace? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr
  19. VarDeclProto <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? AddrSpace? LinkSection?
  21. GlobalVarDecl <- VarDeclProto (EQUAL Expr)? SEMICOLON
  23. ContainerField <- doc_comment? KEYWORD_comptime? !KEYWORD_fn (IDENTIFIER COLON)? TypeExpr ByteAlign? (EQUAL Expr)?
  25. # *** Block Level ***
  26. Statement
  27.     <- KEYWORD_comptime ComptimeStatement
  28.      / KEYWORD_nosuspend BlockExprStatement
  29.      / KEYWORD_suspend BlockExprStatement
  30.      / KEYWORD_defer BlockExprStatement
  31.      / KEYWORD_errdefer Payload? BlockExprStatement
  32.      / IfStatement
  33.      / LabeledStatement
  34.      / SwitchExpr
  35.      / VarDeclExprStatement
  37. ComptimeStatement
  38.     <- BlockExpr
  39.      / VarDeclExprStatement
  41. IfStatement
  42.     <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
  43.      / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
  45. LabeledStatement <- BlockLabel? (Block / LoopStatement)
  47. LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
  49. ForStatement
  50.     <- ForPrefix BlockExpr ( KEYWORD_else Statement )?
  51.      / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
  53. WhileStatement
  54.     <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
  55.      / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
  57. BlockExprStatement
  58.     <- BlockExpr
  59.      / AssignExpr SEMICOLON
  61. BlockExpr <- BlockLabel? Block
  63. # An expression, assignment, or any destructure, as a statement.
  64. VarDeclExprStatement
  65.     <- VarDeclProto (COMMA (VarDeclProto / Expr))* EQUAL Expr SEMICOLON
  66.      / Expr (AssignOp Expr / (COMMA (VarDeclProto / Expr))+ EQUAL Expr)? SEMICOLON
  68. # *** Expression Level ***
  70. # An assignment or a destructure whose LHS are all lvalue expressions.
  71. AssignExpr <- Expr (AssignOp Expr / (COMMA Expr)+ EQUAL Expr)?
  73. SingleAssignExpr <- Expr (AssignOp Expr)?
  75. Expr <- BoolOrExpr
  77. BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
  79. BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
  81. CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
  83. BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
  85. BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
  87. AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
  89. MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
  91. PrefixExpr <- PrefixOp* PrimaryExpr
  93. PrimaryExpr
  94.     <- AsmExpr
  95.      / IfExpr
  96.      / KEYWORD_break BreakLabel? Expr?
  97.      / KEYWORD_comptime Expr
  98.      / KEYWORD_nosuspend Expr
  99.      / KEYWORD_continue BreakLabel?
  100.      / KEYWORD_resume Expr
  101.      / KEYWORD_return Expr?
  102.      / BlockLabel? LoopExpr
  103.      / Block
  104.      / CurlySuffixExpr
  106. IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
  108. Block <- LBRACE Statement* RBRACE
  110. LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
  112. ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
  114. WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
  116. CurlySuffixExpr <- TypeExpr InitList?
  118. InitList
  119.     <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
  120.      / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
  121.      / LBRACE RBRACE
  123. TypeExpr <- PrefixTypeOp* ErrorUnionExpr
  125. ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
  127. SuffixExpr
  128.     <- KEYWORD_async PrimaryTypeExpr SuffixOp* FnCallArguments
  129.      / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
  131. PrimaryTypeExpr
  132.     <- BUILTINIDENTIFIER FnCallArguments
  133.      / CHAR_LITERAL
  134.      / ContainerDecl
  135.      / DOT IDENTIFIER
  136.      / DOT InitList
  137.      / ErrorSetDecl
  138.      / FLOAT
  139.      / FnProto
  140.      / GroupedExpr
  141.      / LabeledTypeExpr
  142.      / IDENTIFIER
  143.      / IfTypeExpr
  144.      / INTEGER
  145.      / KEYWORD_comptime TypeExpr
  146.      / KEYWORD_error DOT IDENTIFIER
  147.      / KEYWORD_anyframe
  148.      / KEYWORD_unreachable
  149.      / STRINGLITERAL
  150.      / SwitchExpr
  152. ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
  154. ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
  156. GroupedExpr <- LPAREN Expr RPAREN
  158. IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
  160. LabeledTypeExpr
  161.     <- BlockLabel Block
  162.      / BlockLabel? LoopTypeExpr
  164. LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
  166. ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
  168. WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
  170. SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
  172. # *** Assembly ***
  173. AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
  175. AsmOutput <- COLON AsmOutputList AsmInput?
  177. AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
  179. AsmInput <- COLON AsmInputList AsmClobbers?
  181. AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
  183. AsmClobbers <- COLON StringList
  185. # *** Helper grammar ***
  186. BreakLabel <- COLON IDENTIFIER
  188. BlockLabel <- IDENTIFIER COLON
  190. FieldInit <- DOT IDENTIFIER EQUAL Expr
  192. WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
  194. LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
  196. AddrSpace <- KEYWORD_addrspace LPAREN Expr RPAREN
  198. # Fn specific
  199. CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
  201. ParamDecl
  202.     <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
  203.      / DOT3
  205. ParamType
  206.     <- KEYWORD_anytype
  207.      / TypeExpr
  209. # Control flow prefixes
  210. IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
  212. WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
  214. ForPrefix <- KEYWORD_for LPAREN ForArgumentsList RPAREN PtrListPayload
  216. # Payloads
  217. Payload <- PIPE IDENTIFIER PIPE
  219. PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
  221. PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
  223. PtrListPayload <- PIPE ASTERISK? IDENTIFIER (COMMA ASTERISK? IDENTIFIER)* COMMA? PIPE
  225. # Switch specific
  226. SwitchProng <- KEYWORD_inline? SwitchCase EQUALRARROW PtrIndexPayload? SingleAssignExpr
  228. SwitchCase
  229.     <- SwitchItem (COMMA SwitchItem)* COMMA?
  230.      / KEYWORD_else
  232. SwitchItem <- Expr (DOT3 Expr)?
  234. # For specific
  235. ForArgumentsList <- ForItem (COMMA ForItem)* COMMA?
  237. ForItem <- Expr (DOT2 Expr?)?
  239. # Operators
  240. AssignOp
  241.     <- ASTERISKEQUAL
  242.      / ASTERISKPIPEEQUAL
  243.      / SLASHEQUAL
  244.      / PERCENTEQUAL
  245.      / PLUSEQUAL
  246.      / PLUSPIPEEQUAL
  247.      / MINUSEQUAL
  248.      / MINUSPIPEEQUAL
  249.      / LARROW2EQUAL
  250.      / LARROW2PIPEEQUAL
  251.      / RARROW2EQUAL
  252.      / AMPERSANDEQUAL
  253.      / CARETEQUAL
  254.      / PIPEEQUAL
  255.      / ASTERISKPERCENTEQUAL
  256.      / PLUSPERCENTEQUAL
  257.      / MINUSPERCENTEQUAL
  258.      / EQUAL
  260. CompareOp
  261.     <- EQUALEQUAL
  262.      / EXCLAMATIONMARKEQUAL
  263.      / LARROW
  264.      / RARROW
  265.      / LARROWEQUAL
  266.      / RARROWEQUAL
  268. BitwiseOp
  269.     <- AMPERSAND
  270.      / CARET
  271.      / PIPE
  272.      / KEYWORD_orelse
  273.      / KEYWORD_catch Payload?
  275. BitShiftOp
  276.     <- LARROW2
  277.      / RARROW2
  278.      / LARROW2PIPE
  280. AdditionOp
  281.     <- PLUS
  282.      / MINUS
  283.      / PLUS2
  284.      / PLUSPERCENT
  285.      / MINUSPERCENT
  286.      / PLUSPIPE
  287.      / MINUSPIPE
  289. MultiplyOp
  290.     <- PIPE2
  291.      / ASTERISK
  292.      / SLASH
  293.      / PERCENT
  294.      / ASTERISK2
  295.      / ASTERISKPERCENT
  296.      / ASTERISKPIPE
  298. PrefixOp
  299.     <- EXCLAMATIONMARK
  300.      / MINUS
  301.      / TILDE
  302.      / MINUSPERCENT
  303.      / AMPERSAND
  304.      / KEYWORD_try
  305.      / KEYWORD_await
  307. PrefixTypeOp
  308.     <- QUESTIONMARK
  309.      / KEYWORD_anyframe MINUSRARROW
  310.      / SliceTypeStart (ByteAlign / AddrSpace / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
  311.      / PtrTypeStart (AddrSpace / KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
  312.      / ArrayTypeStart
  314. SuffixOp
  315.     <- LBRACKET Expr (DOT2 (Expr? (COLON Expr)?)?)? RBRACKET
  316.      / DOT IDENTIFIER
  317.      / DOTASTERISK
  318.      / DOTQUESTIONMARK
  320. FnCallArguments <- LPAREN ExprList RPAREN
  322. # Ptr specific
  323. SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
  325. PtrTypeStart
  326.     <- ASTERISK
  327.      / ASTERISK2
  328.      / LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
  330. ArrayTypeStart <- LBRACKET Expr (COLON Expr)? RBRACKET
  332. # ContainerDecl specific
  333. ContainerDeclAuto <- ContainerDeclType LBRACE container_doc_comment? ContainerMembers RBRACE
  335. ContainerDeclType
  336.     <- KEYWORD_struct (LPAREN Expr RPAREN)?
  337.      / KEYWORD_opaque
  338.      / KEYWORD_enum (LPAREN Expr RPAREN)?
  339.      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
  341. # Alignment
  342. ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
  344. # Lists
  345. IdentifierList <- (doc_comment? IDENTIFIER COMMA)* (doc_comment? IDENTIFIER)?
  347. SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
  349. AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
  351. AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
  353. StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
  355. ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
  357. ExprList <- (Expr COMMA)* Expr?
  359. # *** Tokens ***
  360. eof <- !.
  361. bin <- [01]
  362. bin_ <- '_'? bin
  363. oct <- [0-7]
  364. oct_ <- '_'? oct
  365. hex <- [0-9a-fA-F]
  366. hex_ <- '_'? hex
  367. dec <- [0-9]
  368. dec_ <- '_'? dec
  370. bin_int <- bin bin_*
  371. oct_int <- oct oct_*
  372. dec_int <- dec dec_*
  373. hex_int <- hex hex_*
  375. ox80_oxBF <- [\200-\277]
  376. oxF4 <- '\364'
  377. ox80_ox8F <- [\200-\217]
  378. oxF1_oxF3 <- [\361-\363]
  379. oxF0 <- '\360'
  380. ox90_0xBF <- [\220-\277]
  381. oxEE_oxEF <- [\356-\357]
  382. oxED <- '\355'
  383. ox80_ox9F <- [\200-\237]
  384. oxE1_oxEC <- [\341-\354]
  385. oxE0 <- '\340'
  386. oxA0_oxBF <- [\240-\277]
  387. oxC2_oxDF <- [\302-\337]
  389. # From https://lemire.me/blog/2018/05/09/how-quickly-can-you-check-that-a-string-is-valid-unicode-utf-8/
  390. # First Byte      Second Byte     Third Byte      Fourth Byte
  391. # [0x00,0x7F]
  392. # [0xC2,0xDF]     [0x80,0xBF]
  393. #    0xE0         [0xA0,0xBF]     [0x80,0xBF]
  394. # [0xE1,0xEC]     [0x80,0xBF]     [0x80,0xBF]
  395. #    0xED         [0x80,0x9F]     [0x80,0xBF]
  396. # [0xEE,0xEF]     [0x80,0xBF]     [0x80,0xBF]
  397. #    0xF0         [0x90,0xBF]     [0x80,0xBF]     [0x80,0xBF]
  398. # [0xF1,0xF3]     [0x80,0xBF]     [0x80,0xBF]     [0x80,0xBF]
  399. #    0xF4         [0x80,0x8F]     [0x80,0xBF]     [0x80,0xBF]
  401. mb_utf8_literal <-
  402.        oxF4      ox80_ox8F ox80_oxBF ox80_oxBF
  403.      / oxF1_oxF3 ox80_oxBF ox80_oxBF ox80_oxBF
  404.      / oxF0      ox90_0xBF ox80_oxBF ox80_oxBF
  405.      / oxEE_oxEF ox80_oxBF ox80_oxBF
  406.      / oxED      ox80_ox9F ox80_oxBF
  407.      / oxE1_oxEC ox80_oxBF ox80_oxBF
  408.      / oxE0      oxA0_oxBF ox80_oxBF
  409.      / oxC2_oxDF ox80_oxBF
  411. ascii_char_not_nl_slash_squote <- [\000-\011\013-\046\050-\133\135-\177]
  413. char_escape
  414.     <- "\\x" hex hex
  415.      / "\\u{" hex+ "}"
  416.      / "\\" [nr\\t'"]
  417. char_char
  418.     <- mb_utf8_literal
  419.      / char_escape
  420.      / ascii_char_not_nl_slash_squote
  422. string_char
  423.     <- char_escape
  424.      / [^\\"\n]
  426. container_doc_comment <- ('//!' [^\n]* [ \n]* skip)+
  427. doc_comment <- ('///' [^\n]* [ \n]* skip)+
  428. line_comment <- '//' ![!/][^\n]* / '////' [^\n]*
  429. line_string <- ("\\\\" [^\n]* [ \n]*)+
  430. skip <- ([ \n] / line_comment)*
  432. CHAR_LITERAL <- "'" char_char "'" skip
  433. FLOAT
  434.     <- "0x" hex_int "." hex_int ([pP] [-+]? dec_int)? skip
  435.      /      dec_int "." dec_int ([eE] [-+]? dec_int)? skip
  436.      / "0x" hex_int [pP] [-+]? dec_int skip
  437.      /      dec_int [eE] [-+]? dec_int skip
  438. INTEGER
  439.     <- "0b" bin_int skip
  440.      / "0o" oct_int skip
  441.      / "0x" hex_int skip
  442.      /      dec_int   skip
  443. STRINGLITERALSINGLE <- "\"" string_char* "\"" skip
  444. STRINGLITERAL
  445.     <- STRINGLITERALSINGLE
  446.      / (line_string                 skip)+
  447. IDENTIFIER
  448.     <- !keyword [A-Za-z_] [A-Za-z0-9_]* skip
  449.      / "@" STRINGLITERALSINGLE
  450. BUILTINIDENTIFIER <- "@"[A-Za-z_][A-Za-z0-9_]* skip
  453. AMPERSAND            <- '&'      ![=]      skip
  454. AMPERSANDEQUAL       <- '&='               skip
  455. ASTERISK             <- '*'      ![*%=|]   skip
  456. ASTERISK2            <- '**'               skip
  457. ASTERISKEQUAL        <- '*='               skip
  458. ASTERISKPERCENT      <- '*%'     ![=]      skip
  459. ASTERISKPERCENTEQUAL <- '*%='              skip
  460. ASTERISKPIPE         <- '*|'     ![=]      skip
  461. ASTERISKPIPEEQUAL    <- '*|='              skip
  462. CARET                <- '^'      ![=]      skip
  463. CARETEQUAL           <- '^='               skip
  464. COLON                <- ':'                skip
  465. COMMA                <- ','                skip
  466. DOT                  <- '.'      ![*.?]    skip
  467. DOT2                 <- '..'     ![.]      skip
  468. DOT3                 <- '...'              skip
  469. DOTASTERISK          <- '.*'               skip
  470. DOTQUESTIONMARK      <- '.?'               skip
  471. EQUAL                <- '='      ![>=]     skip
  472. EQUALEQUAL           <- '=='               skip
  473. EQUALRARROW          <- '=>'               skip
  474. EXCLAMATIONMARK      <- '!'      ![=]      skip
  475. EXCLAMATIONMARKEQUAL <- '!='               skip
  476. LARROW               <- '<'      ![<=]     skip
  477. LARROW2              <- '<<'     ![=|]     skip
  478. LARROW2EQUAL         <- '<<='              skip
  479. LARROW2PIPE          <- '<<|'    ![=]      skip
  480. LARROW2PIPEEQUAL     <- '<<|='             skip
  481. LARROWEQUAL          <- '<='               skip
  482. LBRACE               <- '{'                skip
  483. LBRACKET             <- '['                skip
  484. LPAREN               <- '('                skip
  485. MINUS                <- '-'      ![%=>|]   skip
  486. MINUSEQUAL           <- '-='               skip
  487. MINUSPERCENT         <- '-%'     ![=]      skip
  488. MINUSPERCENTEQUAL    <- '-%='              skip
  489. MINUSPIPE            <- '-|'     ![=]      skip
  490. MINUSPIPEEQUAL       <- '-|='              skip
  491. MINUSRARROW          <- '->'               skip
  492. PERCENT              <- '%'      ![=]      skip
  493. PERCENTEQUAL         <- '%='               skip
  494. PIPE                 <- '|'      ![|=]     skip
  495. PIPE2                <- '||'               skip
  496. PIPEEQUAL            <- '|='               skip
  497. PLUS                 <- '+'      ![%+=|]   skip
  498. PLUS2                <- '++'               skip
  499. PLUSEQUAL            <- '+='               skip
  500. PLUSPERCENT          <- '+%'     ![=]      skip
  501. PLUSPERCENTEQUAL     <- '+%='              skip
  502. PLUSPIPE             <- '+|'     ![=]      skip
  503. PLUSPIPEEQUAL        <- '+|='              skip
  504. LETTERC              <- 'c'                skip
  505. QUESTIONMARK         <- '?'                skip
  506. RARROW               <- '>'      ![>=]     skip
  507. RARROW2              <- '>>'     ![=]      skip
  508. RARROW2EQUAL         <- '>>='              skip
  509. RARROWEQUAL          <- '>='               skip
  510. RBRACE               <- '}'                skip
  511. RBRACKET             <- ']'                skip
  512. RPAREN               <- ')'                skip
  513. SEMICOLON            <- ';'                skip
  514. SLASH                <- '/'      ![=]      skip
  515. SLASHEQUAL           <- '/='               skip
  516. TILDE                <- '~'                skip
  518. end_of_word <- ![a-zA-Z0-9_] skip
  519. KEYWORD_addrspace   <- 'addrspace'   end_of_word
  520. KEYWORD_align       <- 'align'       end_of_word
  521. KEYWORD_allowzero   <- 'allowzero'   end_of_word
  522. KEYWORD_and         <- 'and'         end_of_word
  523. KEYWORD_anyframe    <- 'anyframe'    end_of_word
  524. KEYWORD_anytype     <- 'anytype'     end_of_word
  525. KEYWORD_asm         <- 'asm'         end_of_word
  526. KEYWORD_async       <- 'async'       end_of_word
  527. KEYWORD_await       <- 'await'       end_of_word
  528. KEYWORD_break       <- 'break'       end_of_word
  529. KEYWORD_callconv    <- 'callconv'    end_of_word
  530. KEYWORD_catch       <- 'catch'       end_of_word
  531. KEYWORD_comptime    <- 'comptime'    end_of_word
  532. KEYWORD_const       <- 'const'       end_of_word
  533. KEYWORD_continue    <- 'continue'    end_of_word
  534. KEYWORD_defer       <- 'defer'       end_of_word
  535. KEYWORD_else        <- 'else'        end_of_word
  536. KEYWORD_enum        <- 'enum'        end_of_word
  537. KEYWORD_errdefer    <- 'errdefer'    end_of_word
  538. KEYWORD_error       <- 'error'       end_of_word
  539. KEYWORD_export      <- 'export'      end_of_word
  540. KEYWORD_extern      <- 'extern'      end_of_word
  541. KEYWORD_fn          <- 'fn'          end_of_word
  542. KEYWORD_for         <- 'for'         end_of_word
  543. KEYWORD_if          <- 'if'          end_of_word
  544. KEYWORD_inline      <- 'inline'      end_of_word
  545. KEYWORD_noalias     <- 'noalias'     end_of_word
  546. KEYWORD_nosuspend   <- 'nosuspend'   end_of_word
  547. KEYWORD_noinline    <- 'noinline'    end_of_word
  548. KEYWORD_opaque      <- 'opaque'      end_of_word
  549. KEYWORD_or          <- 'or'          end_of_word
  550. KEYWORD_orelse      <- 'orelse'      end_of_word
  551. KEYWORD_packed      <- 'packed'      end_of_word
  552. KEYWORD_pub         <- 'pub'         end_of_word
  553. KEYWORD_resume      <- 'resume'      end_of_word
  554. KEYWORD_return      <- 'return'      end_of_word
  555. KEYWORD_linksection <- 'linksection' end_of_word
  556. KEYWORD_struct      <- 'struct'      end_of_word
  557. KEYWORD_suspend     <- 'suspend'     end_of_word
  558. KEYWORD_switch      <- 'switch'      end_of_word
  559. KEYWORD_test        <- 'test'        end_of_word
  560. KEYWORD_threadlocal <- 'threadlocal' end_of_word
  561. KEYWORD_try         <- 'try'         end_of_word
  562. KEYWORD_union       <- 'union'       end_of_word
  563. KEYWORD_unreachable <- 'unreachable' end_of_word
  564. KEYWORD_usingnamespace <- 'usingnamespace' end_of_word
  565. KEYWORD_var         <- 'var'         end_of_word
  566. KEYWORD_volatile    <- 'volatile'    end_of_word
  567. KEYWORD_while       <- 'while'       end_of_word
  569. keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and
  570.          / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm / KEYWORD_async
  571.          / KEYWORD_await / KEYWORD_break / KEYWORD_callconv / KEYWORD_catch
  572.          / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue / KEYWORD_defer
  573.          / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer / KEYWORD_error / KEYWORD_export
  574.          / KEYWORD_extern / KEYWORD_fn / KEYWORD_for / KEYWORD_if
  575.          / KEYWORD_inline / KEYWORD_noalias / KEYWORD_nosuspend / KEYWORD_noinline
  576.          / KEYWORD_opaque / KEYWORD_or / KEYWORD_orelse / KEYWORD_packed
  577.          / KEYWORD_pub / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
  578.          / KEYWORD_struct / KEYWORD_suspend / KEYWORD_switch / KEYWORD_test
  579.          / KEYWORD_threadlocal / KEYWORD_try / KEYWORD_union / KEYWORD_unreachable
  580.          / KEYWORD_usingnamespace / KEYWORD_var / KEYWORD_volatile / KEYWORD_while

Zen

  • Communicate intent precisely.
  • Edge cases matter.
  • Favor reading code over writing code.
  • Only one obvious way to do things.
  • Runtime crashes are better than bugs.
  • Compile errors are better than runtime crashes.
  • Incremental improvements.
  • Avoid local maximums.
  • Reduce the amount one must remember.
  • Focus on code rather than style.
  • Resource allocation may fail; resource deallocation must succeed.
  • Memory is a resource.
  • Together we serve the users.