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