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