{ "spec": { "file": "LANGUAGE.md", "sha256": "f93dd2f058623ce981ee6746b0afa2261f13388c96fa93ecaa5ce2323da3c9a4", "bytes": 195773, "lines": 5546, "commit": "bf2cba037976586c30d22a48e7b7246d347f54a1", "commitShort": "bf2cba0", "commitDate": "2026-08-22", "origin": "main", "url": "https://github.com/Vox-lang/vox/blob/bf2cba037976586c30d22a48e7b7246d347f54a1/LANGUAGE.md", "parsedAt": "2026-08-22", "brokenAnchors": [] }, "slugRule": [ "A URL is the heading, lowercased, with punctuation dropped and spaces turned into hyphens.", "Each \"##\" section of the spec is a page under /docs/, and every heading inside it is a fragment on that page, so \"File I/O\" is /docs/file-io/ and \"Reading a whole file\" inside it is /docs/file-io/#reading-a-whole-file." ], "entries": [ { "slug": "basics", "url": "/docs/basics/", "title": "Basics", "section": "Basics", "excerpt": "Covers Statements, Case Sensitivity, Comments, Paragraph Breaks (Blank Lines) and 7 more.", "keywords": [ "basics" ] }, { "slug": "statements", "url": "/docs/basics/#statements", "title": "Statements", "section": "Basics", "excerpt": "Every statement ends with a period (.).", "keywords": [ "statements" ] }, { "slug": "case-sensitivity", "url": "/docs/basics/#case-sensitivity", "title": "Case Sensitivity", "section": "Basics", "excerpt": "Keywords are case-insensitive.", "keywords": [ "case", "sensitivity", "case-sensitivity", "print", "if" ] }, { "slug": "comments", "url": "/docs/basics/#comments", "title": "Comments", "section": "Basics", "excerpt": "Comments use parentheses ( ) — just like parenthetical remarks in natural language writing.", "keywords": [ "comments" ] }, { "slug": "paragraph-breaks-blank-lines", "url": "/docs/basics/#paragraph-breaks-blank-lines", "title": "Paragraph Breaks (Blank Lines)", "section": "Basics", "excerpt": "Blank lines (paragraph breaks) organize code into logical sections.", "keywords": [ "paragraph", "breaks", "blank", "lines", "paragraph-breaks-blank-lines", "while", "for", "each", "repeat", "on", "error", "if" ] }, { "slug": "sentence-consumption", "url": "/docs/basics/#sentence-consumption", "title": "Sentence Consumption", "section": "Basics", "excerpt": "Action-consuming constructs (loops, conditionals, error handlers) consume the entire sentence they appear in.", "keywords": [ "sentence", "consumption", "sentence-consumption" ] }, { "slug": "the-termination-rule", "url": "/docs/basics/#the-termination-rule", "title": "The termination rule", "section": "Basics", "excerpt": "Two rules govern where a construct's body ends, and together they explain everything above precisely:", "keywords": [ "the", "termination", "rule", "the-termination-rule", "if", "on", "error", "for", "while", "repeat", "div" ] }, { "slug": "closing-more-than-one-level", "url": "/docs/basics/#closing-more-than-one-level", "title": "Closing more than one level", "section": "Basics", "excerpt": "Rule 1 closes exactly one level, and rule 2 closes all of them.", "keywords": [ "closing", "more", "than", "one", "level", "closing-more-than-one-level", "back", "at", "the", "top", "if", "print" ] }, { "slug": "this-is-how-you-choose-which-if-an-otherwise-belongs-to", "url": "/docs/basics/#this-is-how-you-choose-which-if-an-otherwise-belongs-to", "title": "This is how you choose which if an Otherwise belongs to", "section": "Basics", "excerpt": "An Otherwise (or But if) continues the innermost if that is still open.", "keywords": [ "this", "is", "how", "you", "choose", "which", "if", "an", "otherwise", "belongs", "to", "this-is-how-you-choose-which-if-an-otherwise-belongs-to", "but", "done", "equal" ] }, { "slug": "ranges", "url": "/docs/basics/#ranges", "title": "Ranges", "section": "Basics", "excerpt": "Ranges define a sequence of numbers from a start to an end value.", "keywords": [ "ranges" ] }, { "slug": "loop-expansion", "url": "/docs/basics/#loop-expansion", "title": "Loop Expansion", "section": "Basics", "excerpt": "The each...from syntax is a universal loop expansion that works with any action.", "keywords": [ "loop", "expansion", "loop-expansion", "each...from", "action", "each", "variable", "from", "collection", "additional", "actions" ] }, { "slug": "chained-each-clauses-a-grid", "url": "/docs/basics/#chained-each-clauses-a-grid", "title": "Chained each clauses — a grid", "section": "Basics", "excerpt": "More than one each from clause may appear in a single sentence, joined by and.", "keywords": [ "chained", "each", "clauses", "grid", "chained-each-clauses-a-grid", "variable", "from", "collection", "and", "for", "pair", "10", "20" ] }, { "slug": "conditional-branching-with-but-if", "url": "/docs/basics/#conditional-branching-with-but-if", "title": "Conditional Branching with but if", "section": "Basics", "excerpt": "The but if clause is a generic conditional branch over a base action.", "keywords": [ "conditional", "branching", "with", "but", "if", "conditional-branching-with-but-if", "for", "each", "action", "from", "base", "condition", "alternative", "otherwise", "default" ] }, { "slug": "inline-substitution-with-treating", "url": "/docs/basics/#inline-substitution-with-treating", "title": "Inline Substitution with treating", "section": "Basics", "excerpt": "The treating X as Y clause performs inline value substitution - like bash's ${var//X/Y} but readable.", "keywords": [ "inline", "substitution", "with", "treating", "inline-substitution-with-treating", "as", "var", "each", "from", "collection", "match", "replacement" ] }, { "slug": "types", "url": "/docs/types/", "title": "Types", "section": "Types", "excerpt": "", "keywords": [ "types", "number", "float", "text", "boolean", "true", "false", "list", "map", "buffer", "file", "time", "timer", "thing" ] }, { "slug": "variables", "url": "/docs/variables/", "title": "Variables", "section": "Variables", "excerpt": "Covers Declaration with Type, Declaration with Set/Create, Two Canonical Forms, Declaration Order and 3 more.", "keywords": [ "variables" ] }, { "slug": "declaration-with-type", "url": "/docs/variables/#declaration-with-type", "title": "Declaration with Type", "section": "Variables", "excerpt": "Use a or an before the type to declare a new variable:", "keywords": [ "declaration", "with", "type", "declaration-with-type", "an" ] }, { "slug": "declaration-with-setcreate", "url": "/docs/variables/#declaration-with-setcreate", "title": "Declaration with Set/Create", "section": "Variables", "excerpt": "", "keywords": [ "declaration", "with", "set", "create", "declaration-with-setcreate" ] }, { "slug": "two-canonical-forms", "url": "/docs/variables/#two-canonical-forms", "title": "Two Canonical Forms", "section": "Variables", "excerpt": "Every declarable type supports two equivalent forms, both routed through the same type resolver:", "keywords": [ "two", "canonical", "forms", "two-canonical-forms", "type", "called", "name", "is", "value", "set", "create", "to", "number", "float", "0.0", "text", "boolean", "false", "list", "map", "buffer", "nothing", "timer", "start", "file", "time", "source", "input.txt", "now", "current" ] }, { "slug": "declaration-order", "url": "/docs/variables/#declaration-order", "title": "Declaration Order", "section": "Variables", "excerpt": "Top-level statements run in the order they are written, so a variable must be declared above the code that reads it.", "keywords": [ "declaration", "order", "declaration-order" ] }, { "slug": "assignment-existing-variable", "url": "/docs/variables/#assignment-existing-variable", "title": "Assignment (Existing Variable)", "section": "Variables", "excerpt": "Use the to reference an existing variable:", "keywords": [ "assignment", "existing", "variable", "assignment-existing-variable", "the" ] }, { "slug": "type-immutability", "url": "/docs/variables/#type-immutability", "title": "Type Immutability", "section": "Variables", "excerpt": "A variable's type is fixed at its declaration and never changes — value is the one deliberate exception, covered below.", "keywords": [ "type", "immutability", "type-immutability", "value", "is", "the", "set", "to" ] }, { "slug": "naming-rules", "url": "/docs/variables/#naming-rules", "title": "Naming Rules", "section": "Variables", "excerpt": "A name is an identifier, never a string literal.", "keywords": [ "naming", "rules", "naming-rules", "print", "hello", "bare_word", "number", "called", "total", "is", "multi", "word", "items", "a-za-z_", "a-za-z0-9_", "version", "name's", "length", "name''s", "person's", "name", "see", "utils.vox", "1.0" ] }, { "slug": "names-and-strings", "url": "/docs/names-and-strings/", "title": "Names and strings", "section": "Names and strings", "excerpt": "One token cannot mean two things.", "keywords": [ "names", "and", "strings", "names-and-strings", "is", "get", "five" ] }, { "slug": "functions", "url": "/docs/functions/", "title": "Functions", "section": "Functions", "excerpt": "Covers Definition, Function Scope, Parameter and Local Types, Function Calls and 2 more.", "keywords": [ "functions" ] }, { "slug": "definition", "url": "/docs/functions/#definition", "title": "Definition", "section": "Functions", "excerpt": "No-parameter functions are also valid:", "keywords": [ "definition" ] }, { "slug": "function-scope", "url": "/docs/functions/#function-scope", "title": "Function Scope", "section": "Functions", "excerpt": "Variables declared at top level are global and can be used inside functions — including inside a function written above the declaration, because the body runs when it is called, and it reads the…", "keywords": [ "function", "scope", "function-scope", "0.0", "false", "set", "to", "the", "is", "number", "called", "value" ] }, { "slug": "parameter-and-local-types", "url": "/docs/functions/#parameter-and-local-types", "title": "Parameter and Local Types", "section": "Functions", "excerpt": "Parameters may use any of the 11 expressible types — number, float, text, boolean, list, map, buffer, file, time, timer, value — and a typed parameter supports the same properties and operations as…", "keywords": [ "parameter", "and", "local", "types", "parameter-and-local-types", "number", "float", "text", "boolean", "list", "map", "buffer", "file", "time", "timer", "value", "return", "type" ] }, { "slug": "a-collection-parameter-is-the-callers-collection", "url": "/docs/functions/#a-collection-parameter-is-the-callers-collection", "title": "A collection parameter is the caller's collection", "section": "Functions", "excerpt": "A list or map parameter names the caller's collection, not a copy of it.", "keywords": [ "collection", "parameter", "is", "the", "caller's", "a-collection-parameter-is-the-callers-collection", "list", "map", "thing", "size", "of" ] }, { "slug": "function-calls", "url": "/docs/functions/#function-calls", "title": "Function Calls", "section": "Functions", "excerpt": "In expressions, use the function name followed by of, to, with, or on and arguments:", "keywords": [ "function", "calls", "function-calls", "of", "to", "with", "on" ] }, { "slug": "calling-as-statement", "url": "/docs/functions/#calling-as-statement", "title": "Calling as Statement", "section": "Functions", "excerpt": "", "keywords": [ "calling", "as", "statement", "calling-as-statement" ] }, { "slug": "reading-a-result", "url": "/docs/functions/#reading-a-result", "title": "Reading a result", "section": "Functions", "excerpt": "Return a , is optional in the grammar, but it decides where the result may be read.", "keywords": [ "reading", "result", "reading-a-result", "return", "type", "value" ] }, { "slug": "things", "url": "/docs/things/", "title": "Things", "section": "Things", "excerpt": "Vox's eleven builtin types are the compiler's own composite values — a buffer is [capacity][length][flags][data] with 's reading a field at a fixed offset.", "keywords": [ "things", "capacity", "length", "flags", "data", "examples", "delivery.vox" ] }, { "slug": "defining-a-thing", "url": "/docs/things/#defining-a-thing", "title": "Defining a thing", "section": "Things", "excerpt": "The keyword is thing, and the verb is has.", "keywords": [ "defining", "thing", "defining-a-thing", "has", "type", "called", "name", "is", "literal", "function" ] }, { "slug": "the-article-rule", "url": "/docs/things/#the-article-rule", "title": "The article rule", "section": "Things", "excerpt": "a/an pairs with types and with values coming into being; the pairs with known identifiers.", "keywords": [ "the", "article", "rule", "the-article-rule", "an", "thing", "called", "point", "has", "origin", "point's", "placed", "at", "to", "do", "with", "and" ] }, { "slug": "declarations-and-field-access", "url": "/docs/things/#declarations-and-field-access", "title": "Declarations and field access", "section": "Things", "excerpt": "A thing name is a type noun everywhere the builtin ones are, so every declaration form works.", "keywords": [ "declarations", "and", "field", "access", "declarations-and-field-access", "point", "set", "to", "create" ] }, { "slug": "nesting", "url": "/docs/things/#nesting", "title": "Nesting", "section": "Things", "excerpt": "A field may be a thing, so things nest to any depth.", "keywords": [ "nesting", "route", "number" ] }, { "slug": "value-copy-semantics", "url": "/docs/things/#value-copy-semantics", "title": "Value copy semantics", "section": "Things", "excerpt": "A thing is a value.", "keywords": [ "value", "copy", "semantics", "value-copy-semantics", "is", "set", "to" ] }, { "slug": "printing", "url": "/docs/things/#printing", "title": "Printing", "section": "Things", "excerpt": "Print p. walks the fields in definition order and recurses into the things they hold, map-style.", "keywords": [ "printing", "print", "the", "span", "runs" ] }, { "slug": "equality", "url": "/docs/things/#equality", "title": "Equality", "section": "Things", "excerpt": "is between two values of the same thing compares those same fields at the same depth; is not is its negation.", "keywords": [ "equality", "is", "not", "origin", "span", "greater", "than", "marker" ] }, { "slug": "the-manifest", "url": "/docs/things/#the-manifest", "title": "The manifest", "section": "Things", "excerpt": "A thing's callable API is declared in one place, the manifest: each a function called entry names a member.", "keywords": [ "the", "manifest", "the-manifest", "function", "called", "name", "to", "do", "type", "point's" ] }, { "slug": "the-three-call-forms", "url": "/docs/things/#the-three-call-forms", "title": "The three call forms", "section": "Things", "excerpt": "Three ways to call, one rule each.", "keywords": [ "the", "three", "call", "forms", "the-three-call-forms", "of", "to", "with", "on" ] }, { "slug": "one-identifier-space", "url": "/docs/things/#one-identifier-space", "title": "One identifier space", "section": "Things", "excerpt": "Type names, variable names, and function names share a single global identifier namespace.", "keywords": [ "one", "identifier", "space", "one-identifier-space", "the", "point's", "point", "segment's" ] }, { "slug": "definitions-are-top-level-only", "url": "/docs/things/#definitions-are-top-level-only", "title": "Definitions are top-level only", "section": "Things", "excerpt": "A thing is defined where a function is defined — at the top level.", "keywords": [ "definitions", "are", "top-level", "only", "definitions-are-top-level-only", "if" ] }, { "slug": "cross-file-definitions", "url": "/docs/things/#cross-file-definitions", "title": "Cross-file definitions", "section": "Things", "excerpt": "A thing defined in one file is usable from another via see (the definition is parsed into the program the way a function is).", "keywords": [ "cross-file", "definitions", "cross-file-definitions", "see" ] }, { "slug": "lib-export-of-a-thing-is-not-yet-supported", "url": "/docs/things/#lib-export-of-a-thing-is-not-yet-supported", "title": ".lib export of a thing is not yet supported", "section": "Things", "excerpt": "A .lib interface file names types by noun, and no noun spells a user-defined thing, so an exported signature that takes or returns a thing cannot be written.", "keywords": [ "lib", "export", "of", "thing", "is", "not", "yet", "supported", "lib-export-of-a-thing-is-not-yet-supported", "to", "nudged", "east", "with", "point", "called", "start", "shared", "start's" ] }, { "slug": "sentence-consumption-and-multi-line-definitions", "url": "/docs/things/#sentence-consumption-and-multi-line-definitions", "title": "Sentence consumption and multi-line definitions", "section": "Things", "excerpt": "A thing definition is a new place the sentence consumption rules bite.", "keywords": [ "sentence", "consumption", "and", "multi-line", "definitions", "sentence-consumption-and-multi-line-definitions" ] }, { "slug": "definition-diagnostics", "url": "/docs/things/#definition-diagnostics", "title": "Definition diagnostics", "section": "Things", "excerpt": "The definition construct creates a family of sentences that are never valid Vox.", "keywords": [ "definition", "diagnostics", "definition-diagnostics" ] }, { "slug": "type-predicates-and-the-runtime-tag", "url": "/docs/things/#type-predicates-and-the-runtime-tag", "title": "Type predicates and the runtime tag", "section": "Things", "excerpt": "User-defined things are not in the runtime tag system in v1.", "keywords": [ "type", "predicates", "and", "the", "runtime", "tag", "type-predicates-and-the-runtime-tag", "is", "number", "text", "decimal", "boolean", "list", "map", "point", "value" ] }, { "slug": "expressions", "url": "/docs/expressions/", "title": "Expressions", "section": "Expressions", "excerpt": "Covers Literals, Variable Reference, Arithmetic, Comparisons and 4 more.", "keywords": [ "expressions" ] }, { "slug": "literals", "url": "/docs/expressions/#literals", "title": "Literals", "section": "Expressions", "excerpt": "Note: Float literals are recognized by the presence of a decimal point.", "keywords": [ "literals", "42", "3.14", "2.5", "0.0", "hello", "world", "true", "false", "0xff", "0xdeadbeef", "0b10110100", "0b1111", "as", "number", "float" ] }, { "slug": "variable-reference", "url": "/docs/expressions/#variable-reference", "title": "Variable Reference", "section": "Expressions", "excerpt": "the x - references the variable x", "keywords": [ "variable", "reference", "variable-reference", "the", "number", "for", "each" ] }, { "slug": "arithmetic", "url": "/docs/expressions/#arithmetic", "title": "Arithmetic", "section": "Expressions", "excerpt": "Note: the is optional before variable names in expressions.", "keywords": [ "arithmetic", "the", "as", "type", "number", "add" ] }, { "slug": "comparisons", "url": "/docs/expressions/#comparisons", "title": "Comparisons", "section": "Expressions", "excerpt": "Note: the is optional before variable names in comparisons.", "keywords": [ "comparisons", "the" ] }, { "slug": "property-checks", "url": "/docs/expressions/#property-checks", "title": "Property Checks", "section": "Expressions", "excerpt": "", "keywords": [ "property", "checks", "property-checks" ] }, { "slug": "logical-operators", "url": "/docs/expressions/#logical-operators", "title": "Logical Operators", "section": "Expressions", "excerpt": "not takes the whole condition after it, exactly as the fence above says and exactly as English does: If not heat is limit then, reads \"if it is not the case that heat is limit\", never \"if the…", "keywords": [ "logical", "operators", "logical-operators", "not", "if", "heat", "is", "limit", "then", "and", "or", "door_open", "greeting", "empty" ] }, { "slug": "plural-comparisons-with-are", "url": "/docs/expressions/#plural-comparisons-with-are", "title": "Plural Comparisons with are", "section": "Expressions", "excerpt": "Test multiple variables against the same value using comma-separated subjects:", "keywords": [ "plural", "comparisons", "with", "are", "plural-comparisons-with-are" ] }, { "slug": "type-casting", "url": "/docs/expressions/#type-casting", "title": "Type Casting", "section": "Expressions", "excerpt": "Convert values between types using the as or in keywords.", "keywords": [ "type", "casting", "type-casting", "as", "in" ] }, { "slug": "control-flow", "url": "/docs/control-flow/", "title": "Control Flow", "section": "Control Flow", "excerpt": "Covers If Statement, While Loop, For Each Loop, Repeat and 3 more.", "keywords": [ "control", "flow", "control-flow" ] }, { "slug": "if-statement", "url": "/docs/control-flow/#if-statement", "title": "If Statement", "section": "Control Flow", "excerpt": "With else:", "keywords": [ "if", "statement", "if-statement" ] }, { "slug": "while-loop", "url": "/docs/control-flow/#while-loop", "title": "While Loop", "section": "Control Flow", "excerpt": "Single-line example:", "keywords": [ "while", "loop", "while-loop" ] }, { "slug": "for-each-loop", "url": "/docs/control-flow/#for-each-loop", "title": "For Each Loop", "section": "Control Flow", "excerpt": "Range-based:", "keywords": [ "for", "each", "loop", "for-each-loop" ] }, { "slug": "repeat", "url": "/docs/control-flow/#repeat", "title": "Repeat", "section": "Control Flow", "excerpt": "Run a body a fixed number of times.", "keywords": [ "repeat" ] }, { "slug": "loop-control", "url": "/docs/control-flow/#loop-control", "title": "Loop Control", "section": "Control Flow", "excerpt": "", "keywords": [ "loop", "control", "loop-control" ] }, { "slug": "program-termination", "url": "/docs/control-flow/#program-termination", "title": "Program Termination", "section": "Control Flow", "excerpt": "Immediately exit the program with an exit code:", "keywords": [ "program", "termination", "program-termination" ] }, { "slug": "incrementdecrement", "url": "/docs/control-flow/#incrementdecrement", "title": "Increment/Decrement", "section": "Control Flow", "excerpt": "", "keywords": [ "increment", "decrement", "incrementdecrement" ] }, { "slug": "lists-and-collections", "url": "/docs/lists-and-collections/", "title": "Lists and Collections", "section": "Lists and Collections", "excerpt": "Covers List Literals, Mixed-Type Lists, Nested Lists, Maps and 10 more.", "keywords": [ "lists", "and", "collections", "lists-and-collections" ] }, { "slug": "list-literals", "url": "/docs/lists-and-collections/#list-literals", "title": "List Literals", "section": "Lists and Collections", "excerpt": "Create lists with square brackets containing comma-separated values:", "keywords": [ "list", "literals", "list-literals" ] }, { "slug": "mixed-type-lists", "url": "/docs/lists-and-collections/#mixed-type-lists", "title": "Mixed-Type Lists", "section": "Lists and Collections", "excerpt": "A list may freely hold numbers, texts, decimals, and booleans together.", "keywords": [ "mixed-type", "lists", "mixed-type-lists", "set", "element", "of", "first", "last" ] }, { "slug": "nested-lists", "url": "/docs/lists-and-collections/#nested-lists", "title": "Nested Lists", "section": "Lists and Collections", "excerpt": "A list element may itself be a list.", "keywords": [ "nested", "lists", "nested-lists", "four", "element", "of", "first", "last", "length", "for", "each" ] }, { "slug": "maps", "url": "/docs/lists-and-collections/#maps", "title": "Maps", "section": "Lists and Collections", "excerpt": "A map is a key/value collection — a JSON object.", "keywords": [ "maps", "key", "value", "map's" ] }, { "slug": "type-predicates", "url": "/docs/lists-and-collections/#type-predicates", "title": "Type Predicates", "section": "Lists and Collections", "excerpt": "You can ask what type a value actually holds and branch on it.", "keywords": [ "type", "predicates", "type-predicates", "is", "type-noun", "number", "text", "decimal", "boolean", "list", "map", "integer", "string", "float", "real", "bool", "dictionary", "not" ] }, { "slug": "dynamic-values-value", "url": "/docs/lists-and-collections/#dynamic-values-value", "title": "Dynamic Values (value)", "section": "Lists and Collections", "excerpt": "The value type is a declared dynamic type that carries its runtime tag alongside its payload across the call, so a single function can accept \"whatever this slot holds\" and ask is a ... inside to…", "keywords": [ "dynamic", "values", "value", "dynamic-values-value", "is", "with", "called", "return", "expr" ] }, { "slug": "nothing-the-absent-value", "url": "/docs/lists-and-collections/#nothing-the-absent-value", "title": "Nothing (the absent value)", "section": "Lists and Collections", "excerpt": "nothing is the value that means \"no value here\" — the equivalent of null in other languages.", "keywords": [ "nothing", "the", "absent", "value", "nothing-the-absent-value", "null", "nil" ] }, { "slug": "printing-a-list", "url": "/docs/lists-and-collections/#printing-a-list", "title": "Printing a List", "section": "Lists and Collections", "excerpt": "Printing a list variable directly renders its contents rather than its heap address:", "keywords": [ "printing", "list", "printing-a-list", "four", "key", "value", "_map_print", "print", "xs", "element", "of" ] }, { "slug": "list-properties", "url": "/docs/lists-and-collections/#list-properties", "title": "List Properties", "section": "Lists and Collections", "excerpt": "Access list properties using the 's syntax:", "keywords": [ "list", "properties", "list-properties", "length", "size", "empty", "first", "last" ] }, { "slug": "list-element-access", "url": "/docs/lists-and-collections/#list-element-access", "title": "List Element Access", "section": "Lists and Collections", "excerpt": "Access elements by index (1-indexed):", "keywords": [ "list", "element", "access", "list-element-access" ] }, { "slug": "appending-to-lists", "url": "/docs/lists-and-collections/#appending-to-lists", "title": "Appending to Lists", "section": "Lists and Collections", "excerpt": "Add elements to the end of a list using the append keyword:", "keywords": [ "appending", "to", "lists", "appending-to-lists", "append" ] }, { "slug": "loop-expansion-with-collections", "url": "/docs/lists-and-collections/#loop-expansion-with-collections", "title": "Loop Expansion with Collections", "section": "Lists and Collections", "excerpt": "The each...from syntax works with lists and ranges to execute an action for each item:", "keywords": [ "loop", "expansion", "with", "collections", "loop-expansion-with-collections", "each...from", "action", "each", "variable", "from", "collection" ] }, { "slug": "chained-clauses-the-grid", "url": "/docs/lists-and-collections/#chained-clauses-the-grid", "title": "Chained clauses: the grid", "section": "Lists and Collections", "excerpt": "and joins any number of each clauses in one sentence.", "keywords": [ "chained", "clauses", "the", "grid", "chained-clauses-the-grid", "and", "each" ] }, { "slug": "conditional-branching-with-but-if-lists-and-collections", "url": "/docs/lists-and-collections/#conditional-branching-with-but-if-lists-and-collections", "title": "Conditional Branching with but if (Lists and Collections)", "section": "Lists and Collections", "excerpt": "Use but if as a generic conditional branch over any base action, including inside loops and loop expansion:", "keywords": [ "conditional", "branching", "with", "but", "if", "lists", "and", "collections", "conditional-branching-with-but-if-lists-and-collections" ] }, { "slug": "inline-value-substitution-with-treating", "url": "/docs/lists-and-collections/#inline-value-substitution-with-treating", "title": "Inline Value Substitution with treating", "section": "Lists and Collections", "excerpt": "The treating X as Y clause performs inline value substitution:", "keywords": [ "inline", "value", "substitution", "with", "treating", "inline-value-substitution-with-treating", "as", "each", "var", "from", "collection", "match", "replacement" ] }, { "slug": "inputoutput", "url": "/docs/inputoutput/", "title": "Input/Output", "section": "Input/Output", "excerpt": "Covers Print, Format Strings and Conditional Print.", "keywords": [ "input", "output", "inputoutput" ] }, { "slug": "print", "url": "/docs/inputoutput/#print", "title": "Print", "section": "Input/Output", "excerpt": "Print without newline:", "keywords": [ "print" ] }, { "slug": "format-strings", "url": "/docs/inputoutput/#format-strings", "title": "Format Strings", "section": "Input/Output", "excerpt": "Embed variables and expressions directly in strings using curly braces {}:", "keywords": [ "format", "strings", "format-strings" ] }, { "slug": "format-specifiers", "url": "/docs/inputoutput/#format-specifiers", "title": "Format Specifiers", "section": "Input/Output", "excerpt": "The value inside {} must be a variable or expression, not a bare literal — {255:x} is rejected (255 is read as a variable name).", "keywords": [ "format", "specifiers", "format-specifiers", "var", "name", "alice", "pi", "3.14", "42", "0n", "06", "000042", "0xff", "101", "0o10", "04x", "0x00ff", "255", "number", "called", "is", "50", "255.00" ] }, { "slug": "expressions-in-format-strings", "url": "/docs/inputoutput/#expressions-in-format-strings", "title": "Expressions in Format Strings", "section": "Input/Output", "excerpt": "", "keywords": [ "expressions", "in", "format", "strings", "expressions-in-format-strings" ] }, { "slug": "format-strings-as-values", "url": "/docs/inputoutput/#format-strings-as-values", "title": "Format Strings as Values", "section": "Input/Output", "excerpt": "Format strings are expressions, not just print arguments.", "keywords": [ "format", "strings", "as", "values", "format-strings-as-values", "execute" ] }, { "slug": "format-strings-everywhere", "url": "/docs/inputoutput/#format-strings-everywhere", "title": "Format Strings Everywhere", "section": "Input/Output", "excerpt": "Every statement that takes a string value accepts a format string: write, buffer set/copy/append, filesystem paths (Create a directory called \"{base}/{name}\"), treating clauses, and function…", "keywords": [ "format", "strings", "everywhere", "format-strings-everywhere", "write", "set", "copy", "append", "create", "directory", "called", "base", "name", "treating", "arguments's", "first", "current", "time's", "hour", "0x", "0o", "ratio", "2.50" ] }, { "slug": "declarations-in-branches", "url": "/docs/inputoutput/#declarations-in-branches", "title": "Declarations in Branches", "section": "Input/Output", "excerpt": "A variable (or file handle) declared in EVERY branch of an if/otherwise chain definitely exists afterwards: it can be used after the branch and from inside functions, exactly like a top-level…", "keywords": [ "declarations", "in", "branches", "declarations-in-branches", "if", "otherwise" ] }, { "slug": "escape-sequences", "url": "/docs/inputoutput/#escape-sequences", "title": "Escape Sequences", "section": "Input/Output", "excerpt": "Example:", "keywords": [ "escape", "sequences", "escape-sequences" ] }, { "slug": "conditional-print", "url": "/docs/inputoutput/#conditional-print", "title": "Conditional Print", "section": "Input/Output", "excerpt": "Chained conditions:", "keywords": [ "conditional", "print", "conditional-print" ] }, { "slug": "file-io", "url": "/docs/file-io/", "title": "File I/O", "section": "File I/O", "excerpt": "Covers Buffers, Object Properties, Opening Files, Reading and 6 more.", "keywords": [ "file", "file-io" ] }, { "slug": "buffers", "url": "/docs/file-io/#buffers", "title": "Buffers", "section": "File I/O", "excerpt": "Buffers are memory blocks for I/O operations.", "keywords": [ "buffers" ] }, { "slug": "dynamic-buffers-default", "url": "/docs/file-io/#dynamic-buffers-default", "title": "Dynamic Buffers (default)", "section": "File I/O", "excerpt": "Features:", "keywords": [ "dynamic", "buffers", "default", "dynamic-buffers-default" ] }, { "slug": "fixed-size-buffers", "url": "/docs/file-io/#fixed-size-buffers", "title": "Fixed-Size Buffers", "section": "File I/O", "excerpt": "Features:", "keywords": [ "fixed-size", "buffers", "fixed-size-buffers" ] }, { "slug": "object-properties", "url": "/docs/file-io/#object-properties", "title": "Object Properties", "section": "File I/O", "excerpt": "Access properties of objects using the 's syntax:", "keywords": [ "object", "properties", "object-properties" ] }, { "slug": "universal-properties", "url": "/docs/file-io/#universal-properties", "title": "Universal Properties", "section": "File I/O", "excerpt": "Every variable has a type property that reports its declared type as text:", "keywords": [ "universal", "properties", "universal-properties", "type", "static", "dynamic", "number", "text" ] }, { "slug": "buffer-properties", "url": "/docs/file-io/#buffer-properties", "title": "Buffer Properties", "section": "File I/O", "excerpt": "Example:", "keywords": [ "buffer", "properties", "buffer-properties", "size", "length", "capacity", "empty", "full" ] }, { "slug": "buffer-resizing", "url": "/docs/file-io/#buffer-resizing", "title": "Buffer Resizing", "section": "File I/O", "excerpt": "Resize a buffer to a new capacity:", "keywords": [ "buffer", "resizing", "buffer-resizing", "resize", "reallocate", "grow", "shrink" ] }, { "slug": "buffer-byte-access", "url": "/docs/file-io/#buffer-byte-access", "title": "Buffer Byte Access", "section": "File I/O", "excerpt": "Read and write individual bytes in buffers and strings by position.", "keywords": [ "buffer", "byte", "access", "buffer-byte-access" ] }, { "slug": "buffer-append-and-copy", "url": "/docs/file-io/#buffer-append-and-copy", "title": "Buffer Append and Copy", "section": "File I/O", "excerpt": "Efficiently combine buffers without byte-by-byte loops:", "keywords": [ "buffer", "append", "and", "copy", "buffer-append-and-copy" ] }, { "slug": "file-properties", "url": "/docs/file-io/#file-properties", "title": "File Properties", "section": "File I/O", "excerpt": "Example:", "keywords": [ "file", "properties", "file-properties", "size", "descriptor", "readable", "writable", "modified", "accessed", "permissions" ] }, { "slug": "list-properties-object-properties", "url": "/docs/file-io/#list-properties-object-properties", "title": "List Properties (Object Properties)", "section": "File I/O", "excerpt": "Example:", "keywords": [ "list", "properties", "object", "list-properties-object-properties", "length", "size", "empty", "first", "last" ] }, { "slug": "list-element-access-object-properties", "url": "/docs/file-io/#list-element-access-object-properties", "title": "List Element Access (Object Properties)", "section": "File I/O", "excerpt": "Access list elements by index.", "keywords": [ "list", "element", "access", "object", "properties", "list-element-access-object-properties" ] }, { "slug": "number-properties", "url": "/docs/file-io/#number-properties", "title": "Number Properties", "section": "File I/O", "excerpt": "Example:", "keywords": [ "number", "properties", "number-properties", "even", "odd", "positive", "negative", "zero", "absolute", "sign" ] }, { "slug": "opening-files", "url": "/docs/file-io/#opening-files", "title": "Opening Files", "section": "File I/O", "excerpt": "Open files for reading, writing, or appending:", "keywords": [ "opening", "files", "opening-files" ] }, { "slug": "reading", "url": "/docs/file-io/#reading", "title": "Reading", "section": "File I/O", "excerpt": "At a glance:", "keywords": [ "reading", "read", "from", "into", "line" ] }, { "slug": "seeking", "url": "/docs/file-io/#seeking", "title": "Seeking", "section": "File I/O", "excerpt": "Move a file descriptor position before reading:", "keywords": [ "seeking" ] }, { "slug": "writing", "url": "/docs/file-io/#writing", "title": "Writing", "section": "File I/O", "excerpt": "Write strings, buffers, or special values to files:", "keywords": [ "writing", "write" ] }, { "slug": "closing-files", "url": "/docs/file-io/#closing-files", "title": "Closing Files", "section": "File I/O", "excerpt": "Close file handles when done:", "keywords": [ "closing", "files", "closing-files" ] }, { "slug": "file-operations", "url": "/docs/file-io/#file-operations", "title": "File Operations", "section": "File I/O", "excerpt": "Check if a file (or any path) is available:", "keywords": [ "file", "operations", "file-operations", "is", "available", "access", "f_ok" ] }, { "slug": "error-handling", "url": "/docs/file-io/#error-handling", "title": "Error Handling", "section": "File I/O", "excerpt": "Operations that can fail (file reads, buffer operations, out-of-bounds access) set an error flag.", "keywords": [ "error", "handling", "error-handling", "on" ] }, { "slug": "on-error-handler", "url": "/docs/file-io/#on-error-handler", "title": "On Error Handler", "section": "File I/O", "excerpt": "Check for errors after specific operations with On error:", "keywords": [ "on", "error", "handler", "on-error-handler" ] }, { "slug": "resource-safety", "url": "/docs/file-io/#resource-safety", "title": "Resource Safety", "section": "File I/O", "excerpt": "vox provides memory safety through automatic resource management.", "keywords": [ "resource", "safety", "resource-safety", "vox" ] }, { "slug": "memory-safety-guarantees", "url": "/docs/file-io/#memory-safety-guarantees", "title": "Memory Safety Guarantees", "section": "File I/O", "excerpt": "", "keywords": [ "memory", "safety", "guarantees", "memory-safety-guarantees" ] }, { "slug": "automatic-cleanup", "url": "/docs/file-io/#automatic-cleanup", "title": "Automatic Cleanup", "section": "File I/O", "excerpt": "All resources are automatically cleaned up on program exit:", "keywords": [ "automatic", "cleanup", "automatic-cleanup" ] }, { "slug": "dynamic-buffers", "url": "/docs/file-io/#dynamic-buffers", "title": "Dynamic Buffers", "section": "File I/O", "excerpt": "Buffers start at zero capacity and grow automatically.", "keywords": [ "dynamic", "buffers", "dynamic-buffers" ] }, { "slug": "file-descriptor-tracking", "url": "/docs/file-io/#file-descriptor-tracking", "title": "File Descriptor Tracking", "section": "File I/O", "excerpt": "Files are tracked at runtime for guaranteed cleanup:", "keywords": [ "file", "descriptor", "tracking", "file-descriptor-tracking" ] }, { "slug": "safety-vs-c-comparison", "url": "/docs/file-io/#safety-vs-c-comparison", "title": "Safety vs C Comparison", "section": "File I/O", "excerpt": "", "keywords": [ "safety", "vs", "comparison", "safety-vs-c-comparison" ] }, { "slug": "directories-mounting-and-process-control", "url": "/docs/directories-mounting-and-process-control/", "title": "Directories, Mounting, and Process Control", "section": "Directories, Mounting, and Process Control", "excerpt": "These constructs were added for writing early-userspace/init-style programs in Vox - see examples/initramfs.vox for a complete, working early-userspace init sequence exercising all of them together.", "keywords": [ "directories", "mounting", "and", "process", "control", "directories-mounting-and-process-control" ] }, { "slug": "directories", "url": "/docs/directories-mounting-and-process-control/#directories", "title": "Directories", "section": "Directories, Mounting, and Process Control", "excerpt": "Rules:", "keywords": [ "directories", "create", "directory", "called", "path", "mkdir", "0755", "remove", "the", "delete", "rmdir", "change", "to", "chdir", "on", "error" ] }, { "slug": "mounting-filesystems", "url": "/docs/directories-mounting-and-process-control/#mounting-filesystems", "title": "Mounting Filesystems", "section": "Directories, Mounting, and Process Control", "excerpt": "Rules:", "keywords": [ "mounting", "filesystems", "mounting-filesystems", "mount", "source", "at", "target", "with", "type", "fstype", "options", "none", "move", "bind", "ms_move", "ms_bind", "unmount", "umount2", "umount", "lazily", "mnt_detach" ] }, { "slug": "device-nodes", "url": "/docs/directories-mounting-and-process-control/#device-nodes", "title": "Device Nodes", "section": "Directories, Mounting, and Process Control", "excerpt": "mknod(2). type is \"c\" (character device) or \"b\" (block device); major/minor are the standard Linux device-driver identification numbers (see man 4 null/the kernel's…", "keywords": [ "device", "nodes", "device-nodes", "mknod", "type", "major", "minor", "man", "null", "documentation", "admin-guide", "devices.txt" ] }, { "slug": "symbolic-links", "url": "/docs/directories-mounting-and-process-control/#symbolic-links", "title": "Symbolic Links", "section": "Directories, Mounting, and Process Control", "excerpt": "symlink(2): Create symbolic link from '' to \"\".", "keywords": [ "symbolic", "links", "symbolic-links", "symlink", "create", "link", "from", "target", "to", "linkpath" ] }, { "slug": "switching-the-root-filesystem", "url": "/docs/directories-mounting-and-process-control/#switching-the-root-filesystem", "title": "Switching the Root Filesystem", "section": "Directories, Mounting, and Process Control", "excerpt": "pivot_root(2). put_old (the second path) must be a directory that already exists inside new_root - create it after mounting the new root, not before.", "keywords": [ "switching", "the", "root", "filesystem", "switching-the-root-filesystem", "pivot_root", "put_old", "new_root", "oldroot", "unmount", "lazily", "chdir" ] }, { "slug": "executing-programs", "url": "/docs/directories-mounting-and-process-control/#executing-programs", "title": "Executing Programs", "section": "Directories, Mounting, and Process Control", "excerpt": "execve(2) - replaces the current process image entirely.", "keywords": [ "executing", "programs", "executing-programs", "execve", "execute", "path", "argv", "null", "with", "arguments", "list" ] }, { "slug": "process-control-fork-and-reap", "url": "/docs/directories-mounting-and-process-control/#process-control-fork-and-reap", "title": "Process Control: fork and reap", "section": "Directories, Mounting, and Process Control", "excerpt": "These are expressions, not statements - use them anywhere an expression is valid (typically the right-hand side of Set/a number called ... is).", "keywords": [ "process", "control", "fork", "and", "reap", "process-control-fork-and-reap", "set", "number", "called", "is", "the", "any", "child", "wait4", "pid", "pid-expr" ] }, { "slug": "non-blocking-reap-without-waiting", "url": "/docs/directories-mounting-and-process-control/#non-blocking-reap-without-waiting", "title": "Non-blocking reap: without waiting", "section": "Directories, Mounting, and Process Control", "excerpt": "Any reap form takes a without waiting suffix, which calls wait4(2) with WNOHANG instead of blocking:", "keywords": [ "non-blocking", "reap", "without", "waiting", "non-blocking-reap-without-waiting", "wait4", "wnohang" ] }, { "slug": "the-reaped-status", "url": "/docs/directories-mounting-and-process-control/#the-reaped-status", "title": "The reaped status", "section": "Directories, Mounting, and Process Control", "excerpt": "the reaped status is an expression yielding the raw wait4 status word as a plain number — exactly the int status the kernel writes, undecoded.", "keywords": [ "the", "reaped", "status", "the-reaped-status", "wait4", "int", "data", "bss", "_start", "shared", "tests", "102_fork_reap.vox", "set", "to", "reap", "any", "child", "process" ] }, { "slug": "decoding-the-status", "url": "/docs/directories-mounting-and-process-control/#decoding-the-status", "title": "Decoding the status", "section": "Directories, Mounting, and Process Control", "excerpt": "The compiler knows nothing about the wait-status encoding — the reaped status hands back the raw word, and a program decodes it with divide, modulo, and bit-and.", "keywords": [ "decoding", "the", "status", "decoding-the-status", "reaped", "divide", "modulo", "bit-and", "crashed", "exited", "normally", "sys", "wait.h", "process" ] }, { "slug": "a-supervisor-loop-with-no-shelling-out", "url": "/docs/directories-mounting-and-process-control/#a-supervisor-loop-with-no-shelling-out", "title": "A supervisor loop, with no shelling out", "section": "Directories, Mounting, and Process Control", "excerpt": "These pieces compose into a complete supervisor — poll a child with non-blocking reap, time it out, kill it, and report how it died — using only Vox, no /bin/sh and no coreutils.…", "keywords": [ "supervisor", "loop", "with", "no", "shelling", "out", "a-supervisor-loop-with-no-shelling-out", "bin", "sh", "examples", "supervisor.vox", "the", "clock's", "elapsed", "in", "milliseconds" ] }, { "slug": "send-a-signal-send-signal", "url": "/docs/directories-mounting-and-process-control/#send-a-signal-send-signal", "title": "Send a signal: Send signal", "section": "Directories, Mounting, and Process Control", "excerpt": "Unlike fork/reap, this is a statement, not an expression:", "keywords": [ "send", "signal", "send-a-signal-send-signal", "fork", "reap", "kill", "pid-expr", "rdi", "n-expr", "rsi", "child", "process" ] }, { "slug": "system-control-shutdown-reboot-halt", "url": "/docs/directories-mounting-and-process-control/#system-control-shutdown-reboot-halt", "title": "System Control: Shutdown, Reboot, Halt", "section": "Directories, Mounting, and Process Control", "excerpt": "reboot(2), requiring CAP_SYS_BOOT (root).", "keywords": [ "system", "control", "shutdown", "reboot", "halt", "system-control-shutdown-reboot-halt", "cap_sys_boot", "sync", "poweroff", "linux_reboot_cmd_power_off", "restart", "linux_reboot_cmd_restart", "linux_reboot_cmd_halt" ] }, { "slug": "time-and-timers", "url": "/docs/time-and-timers/", "title": "Time and Timers", "section": "Time and Timers", "excerpt": "Covers Getting Current Time, Time Properties, Inline Time Access, Sleep / Wait and Timers.", "keywords": [ "time", "and", "timers", "time-and-timers" ] }, { "slug": "getting-current-time", "url": "/docs/time-and-timers/#getting-current-time", "title": "Getting Current Time", "section": "Time and Timers", "excerpt": "Get the current date/time as a time value:", "keywords": [ "getting", "current", "time", "getting-current-time" ] }, { "slug": "time-properties", "url": "/docs/time-and-timers/#time-properties", "title": "Time Properties", "section": "Time and Timers", "excerpt": "Access components of a time value using the 's property syntax:", "keywords": [ "time", "properties", "time-properties", "hour", "minute", "second", "day", "month", "year", "unix" ] }, { "slug": "inline-time-access", "url": "/docs/time-and-timers/#inline-time-access", "title": "Inline Time Access", "section": "Time and Timers", "excerpt": "Access current time properties directly without storing:", "keywords": [ "inline", "time", "access", "inline-time-access" ] }, { "slug": "sleep-wait", "url": "/docs/time-and-timers/#sleep-wait", "title": "Sleep / Wait", "section": "Time and Timers", "excerpt": "Pause program execution for a specified duration:", "keywords": [ "sleep", "wait", "sleep-wait" ] }, { "slug": "timers", "url": "/docs/time-and-timers/#timers", "title": "Timers", "section": "Time and Timers", "excerpt": "Timers are stopwatches for measuring durations.", "keywords": [ "timers" ] }, { "slug": "creating-a-timer", "url": "/docs/time-and-timers/#creating-a-timer", "title": "Creating a Timer", "section": "Time and Timers", "excerpt": "", "keywords": [ "creating", "timer", "creating-a-timer" ] }, { "slug": "starting-and-stopping", "url": "/docs/time-and-timers/#starting-and-stopping", "title": "Starting and Stopping", "section": "Time and Timers", "excerpt": "Alternative spellings:", "keywords": [ "starting", "and", "stopping", "starting-and-stopping", "start", "begin", "stop", "finish" ] }, { "slug": "timer-properties", "url": "/docs/time-and-timers/#timer-properties", "title": "Timer Properties", "section": "Time and Timers", "excerpt": "", "keywords": [ "timer", "properties", "timer-properties", "duration", "elapsed", "start", "time", "end", "running" ] }, { "slug": "getting-duration", "url": "/docs/time-and-timers/#getting-duration", "title": "Getting Duration", "section": "Time and Timers", "excerpt": "Use in to cast duration to a specific unit:", "keywords": [ "getting", "duration", "getting-duration", "in" ] }, { "slug": "complete-timer-example", "url": "/docs/time-and-timers/#complete-timer-example", "title": "Complete Timer Example", "section": "Time and Timers", "excerpt": "", "keywords": [ "complete", "timer", "example", "complete-timer-example" ] }, { "slug": "formatted-time-output", "url": "/docs/time-and-timers/#formatted-time-output", "title": "Formatted Time Output", "section": "Time and Timers", "excerpt": "Combine time properties with the zero-pad format specifier (see Format Specifiers) for formatted output.", "keywords": [ "formatted", "time", "output", "formatted-time-output" ] }, { "slug": "command-line-arguments", "url": "/docs/command-line-arguments/", "title": "Command-Line Arguments", "section": "Command-Line Arguments", "excerpt": "Access command-line arguments using the 's property syntax.", "keywords": [ "command-line", "arguments", "command-line-arguments" ] }, { "slug": "arguments-properties", "url": "/docs/command-line-arguments/#arguments-properties", "title": "Arguments Properties", "section": "Command-Line Arguments", "excerpt": "", "keywords": [ "arguments", "properties", "arguments-properties", "count", "arguments's", "name", "first", "second", "last", "empty", "all", "raw" ] }, { "slug": "basic-usage", "url": "/docs/command-line-arguments/#basic-usage", "title": "Basic Usage", "section": "Command-Line Arguments", "excerpt": "", "keywords": [ "basic", "usage", "basic-usage" ] }, { "slug": "accessing-user-arguments", "url": "/docs/command-line-arguments/#accessing-user-arguments", "title": "Accessing User Arguments", "section": "Command-Line Arguments", "excerpt": "", "keywords": [ "accessing", "user", "arguments", "accessing-user-arguments" ] }, { "slug": "checking-if-arguments-were-provided", "url": "/docs/command-line-arguments/#checking-if-arguments-were-provided", "title": "Checking if Arguments Were Provided", "section": "Command-Line Arguments", "excerpt": "", "keywords": [ "checking", "if", "arguments", "were", "provided", "checking-if-arguments-were-provided" ] }, { "slug": "dynamic-index-access", "url": "/docs/command-line-arguments/#dynamic-index-access", "title": "Dynamic Index Access", "section": "Command-Line Arguments", "excerpt": "For accessing arguments by a computed index, use the argument at syntax:", "keywords": [ "dynamic", "index", "access", "dynamic-index-access", "argument", "at" ] }, { "slug": "declarative-flag-parsing", "url": "/docs/command-line-arguments/#declarative-flag-parsing", "title": "Declarative Flag Parsing", "section": "Command-Line Arguments", "excerpt": "Vox supports declarative CLI flag parsing with a schema-first style.", "keywords": [ "declarative", "flag", "parsing", "declarative-flag-parsing" ] }, { "slug": "declare-a-flag-schema", "url": "/docs/command-line-arguments/#declare-a-flag-schema", "title": "1) Declare a flag schema", "section": "Command-Line Arguments", "excerpt": "Define each supported flag once, including aliases and type:", "keywords": [ "declare", "flag", "schema", "declare-a-flag-schema" ] }, { "slug": "optional-schema-modifiers", "url": "/docs/command-line-arguments/#optional-schema-modifiers", "title": "2) Optional schema modifiers", "section": "Command-Line Arguments", "excerpt": "Flags may be marked as required and/or given defaults:", "keywords": [ "optional", "schema", "modifiers", "optional-schema-modifiers", "with", "default", "and", "is", "required", "text", "number", "boolean", "empty" ] }, { "slug": "parse-point-explicit-or-automatic", "url": "/docs/command-line-arguments/#parse-point-explicit-or-automatic", "title": "3) Parse point: explicit or automatic", "section": "Command-Line Arguments", "excerpt": "You can parse flags explicitly:", "keywords": [ "parse", "point", "explicit", "or", "automatic", "parse-point-explicit-or-automatic" ] }, { "slug": "placement-rules", "url": "/docs/command-line-arguments/#placement-rules", "title": "4) Placement rules", "section": "Command-Line Arguments", "excerpt": "Flag schema declarations are valid as long as they appear before parsing occurs.", "keywords": [ "placement", "rules", "placement-rules", "parse", "flags" ] }, { "slug": "argumentss-all-vs-argumentss-raw", "url": "/docs/command-line-arguments/#argumentss-all-vs-argumentss-raw", "title": "5) arguments's all vs arguments's raw", "section": "Command-Line Arguments", "excerpt": "After parsing:", "keywords": [ "arguments's", "all", "vs", "raw", "argumentss-all-vs-argumentss-raw" ] }, { "slug": "unix-separator", "url": "/docs/command-line-arguments/#unix-separator", "title": "6) Unix -- separator", "section": "Command-Line Arguments", "excerpt": "-- stops flag processing.", "keywords": [ "unix", "separator", "unix-separator" ] }, { "slug": "practical-pattern", "url": "/docs/command-line-arguments/#practical-pattern", "title": "7) Practical pattern", "section": "Command-Line Arguments", "excerpt": "", "keywords": [ "practical", "pattern", "practical-pattern" ] }, { "slug": "environment-variables", "url": "/docs/environment-variables/", "title": "Environment Variables", "section": "Environment Variables", "excerpt": "Access environment variables using the 's property syntax.", "keywords": [ "environment", "variables", "environment-variables" ] }, { "slug": "environment-properties", "url": "/docs/environment-variables/#environment-properties", "title": "Environment Properties", "section": "Environment Variables", "excerpt": "", "keywords": [ "environment", "properties", "environment-properties", "count", "environment's", "first", "last", "empty", "name", "home" ] }, { "slug": "reading-environment-variables", "url": "/docs/environment-variables/#reading-environment-variables", "title": "Reading Environment Variables", "section": "Environment Variables", "excerpt": "", "keywords": [ "reading", "environment", "variables", "reading-environment-variables" ] }, { "slug": "environment-variable-count", "url": "/docs/environment-variables/#environment-variable-count", "title": "Environment Variable Count", "section": "Environment Variables", "excerpt": "", "keywords": [ "environment", "variable", "count", "environment-variable-count" ] }, { "slug": "iterating-environment-variables", "url": "/docs/environment-variables/#iterating-environment-variables", "title": "Iterating Environment Variables", "section": "Environment Variables", "excerpt": "", "keywords": [ "iterating", "environment", "variables", "iterating-environment-variables" ] }, { "slug": "checking-if-variable-exists", "url": "/docs/environment-variables/#checking-if-variable-exists", "title": "Checking if Variable Exists", "section": "Environment Variables", "excerpt": "", "keywords": [ "checking", "if", "variable", "exists", "checking-if-variable-exists" ] }, { "slug": "complete-example", "url": "/docs/environment-variables/#complete-example", "title": "Complete Example", "section": "Environment Variables", "excerpt": "Note: The argument and environment variable functions are only included in the binary when used, keeping programs that don't need them small and efficient.", "keywords": [ "complete", "example", "complete-example" ] }, { "slug": "operators", "url": "/docs/operators/", "title": "Operators", "section": "Operators", "excerpt": "Covers Arithmetic Operators, Comparison Operators, Logical Operators (table) and Bitwise Operators.", "keywords": [ "operators" ] }, { "slug": "arithmetic-operators", "url": "/docs/operators/#arithmetic-operators", "title": "Arithmetic Operators", "section": "Operators", "excerpt": "", "keywords": [ "arithmetic", "operators", "arithmetic-operators", "add", "plus", "subtract", "minus", "multiply", "times", "divide", "modulo", "mod", "remainder" ] }, { "slug": "comparison-operators", "url": "/docs/operators/#comparison-operators", "title": "Comparison Operators", "section": "Operators", "excerpt": "", "keywords": [ "comparison", "operators", "comparison-operators", "is", "equal", "to", "not", "greater", "than", "less", "or" ] }, { "slug": "logical-operators-table", "url": "/docs/operators/#logical-operators-table", "title": "Logical Operators (table)", "section": "Operators", "excerpt": "isn't and aren't are contractions, and each stands for two words: isn't is is not, aren't is are not.", "keywords": [ "logical", "operators", "table", "logical-operators-table", "and", "or", "not", "isn't", "aren't", "is", "are", "if", "v1", "v2", "then", "don't", "it's", "length", "it" ] }, { "slug": "bitwise-operators", "url": "/docs/operators/#bitwise-operators", "title": "Bitwise Operators", "section": "Operators", "excerpt": "Examples:", "keywords": [ "bitwise", "operators", "bitwise-operators", "bit-and", "bit-or", "bit-xor", "bit-shift-left", "bit-shift-right" ] }, { "slug": "keywords", "url": "/docs/keywords/", "title": "Keywords", "section": "Keywords", "excerpt": "Covers Articles (Context-Dependent), Statement Starters, Flag Schema, Connectors and 4 more.", "keywords": [ "keywords" ] }, { "slug": "articles-context-dependent", "url": "/docs/keywords/#articles-context-dependent", "title": "Articles (Context-Dependent)", "section": "Keywords", "excerpt": "", "keywords": [ "articles", "context-dependent", "articles-context-dependent", "an", "the" ] }, { "slug": "statement-starters", "url": "/docs/keywords/#statement-starters", "title": "Statement Starters", "section": "Keywords", "excerpt": "", "keywords": [ "statement", "starters", "statement-starters", "print", "set", "create", "if", "when", "while", "for", "to", "return", "increment", "decrement", "break", "continue", "exit", "append", "change", "remove", "delete", "mount", "unmount", "umount", "pivot", "pivot_root", "execute", "execve", "shutdown", "poweroff", "reboot", "restart", "halt", "fork", "reap", "wait4", "send", "signal", "kill", "child", "process" ] }, { "slug": "flag-schema", "url": "/docs/keywords/#flag-schema", "title": "Flag Schema", "section": "Keywords", "excerpt": "", "keywords": [ "flag", "schema", "flag-schema", "called", "parse", "flags", "required", "default" ] }, { "slug": "connectors", "url": "/docs/keywords/#connectors", "title": "Connectors", "section": "Keywords", "excerpt": "", "keywords": [ "connectors", "with", "called", "named", "of", "to", "on", "and", "or", "but", "then", "otherwise", "else", "from" ] }, { "slug": "the-and-keyword", "url": "/docs/keywords/#the-and-keyword", "title": "The and Keyword", "section": "Keywords", "excerpt": "The word and has multiple context-dependent meanings:", "keywords": [ "the", "and", "keyword", "the-and-keyword", "if", "then", "with", "number", "called", "add", "of", "are", "true" ] }, { "slug": "reserved-aliases", "url": "/docs/keywords/#reserved-aliases", "title": "Reserved Aliases", "section": "Keywords", "excerpt": "A few alternate spellings are also reserved because the compiler recognizes them as aliases for canonical keywords:", "keywords": [ "reserved", "aliases", "reserved-aliases", "ms", "milliseconds", "wait", "500", "message", "text", "called", "string", "number", "is" ] }, { "slug": "two-classes-of-special-word", "url": "/docs/keywords/#two-classes-of-special-word", "title": "Two classes of special word", "section": "Keywords", "excerpt": "Not every word with a special meaning is reserved.", "keywords": [ "two", "classes", "of", "special", "word", "two-classes-of-special-word", "times", "add", "start", "begin", "stop", "finish", "send", "waiting", "without", "available", "is", "name", "count", "the", "argument", "environment", "variable", "number", "called", "arguments's", "capacity", "with", "raw", "all", "numbers", "from", "between", "first", "last", "second", "wait", "set", "to", "seconds", "size", "length", "bytes", "in", "version", "library", "see", "lib" ] }, { "slug": "contextual-keywords-things", "url": "/docs/keywords/#contextual-keywords-things", "title": "Contextual Keywords (Things)", "section": "Keywords", "excerpt": "Three words the things feature claims only inside their construct, and treats as ordinary identifiers everywhere else — the same treatment send/begin/stop get for timers.", "keywords": [ "contextual", "keywords", "things", "contextual-keywords-things", "send", "begin", "stop", "number", "called", "thing", "is", "to", "do", "name", "has", "the", "type", "member", "point's", "placed", "at" ] }, { "slug": "examples", "url": "/docs/examples/", "title": "Examples", "section": "Examples", "excerpt": "Covers Hello World, Variables and Arithmetic, Function Definition and Call, Counting Loop and FizzBuzz.", "keywords": [ "examples" ] }, { "slug": "hello-world", "url": "/docs/examples/#hello-world", "title": "Hello World", "section": "Examples", "excerpt": "", "keywords": [ "hello", "world", "hello-world" ] }, { "slug": "variables-and-arithmetic", "url": "/docs/examples/#variables-and-arithmetic", "title": "Variables and Arithmetic", "section": "Examples", "excerpt": "", "keywords": [ "variables", "and", "arithmetic", "variables-and-arithmetic" ] }, { "slug": "function-definition-and-call", "url": "/docs/examples/#function-definition-and-call", "title": "Function Definition and Call", "section": "Examples", "excerpt": "", "keywords": [ "function", "definition", "and", "call", "function-definition-and-call" ] }, { "slug": "counting-loop", "url": "/docs/examples/#counting-loop", "title": "Counting Loop", "section": "Examples", "excerpt": "", "keywords": [ "counting", "loop", "counting-loop" ] }, { "slug": "fizzbuzz", "url": "/docs/examples/#fizzbuzz", "title": "FizzBuzz", "section": "Examples", "excerpt": "", "keywords": [ "fizzbuzz" ] }, { "slug": "libraries-and-imports", "url": "/docs/libraries-and-imports/", "title": "Libraries and Imports", "section": "Libraries and Imports", "excerpt": "Covers The see Keyword and Shared libraries.", "keywords": [ "libraries", "and", "imports", "libraries-and-imports" ] }, { "slug": "the-see-keyword", "url": "/docs/libraries-and-imports/#the-see-keyword", "title": "The see Keyword", "section": "Libraries and Imports", "excerpt": "see pulls in code from another file.", "keywords": [ "the", "see", "keyword", "the-see-keyword", "path", "vox", "lib", "version", "ver", "from" ] }, { "slug": "shared-libraries", "url": "/docs/libraries-and-imports/#shared-libraries", "title": "Shared libraries", "section": "Libraries and Imports", "excerpt": "A shared library is a .so you build from Vox and call from Vox — or from C, Rust, or any other host.", "keywords": [ "shared", "libraries", "shared-libraries", "so", "vox", "see", "lib", "location" ] }, { "slug": "writing-a-library", "url": "/docs/libraries-and-imports/#writing-a-library", "title": "Writing a library", "section": "Libraries and Imports", "excerpt": "Add a Library declaration at the top of a .vox file, then build with --shared:", "keywords": [ "writing", "library", "writing-a-library", "vox", "shared" ] }, { "slug": "the-lib-file", "url": "/docs/libraries-and-imports/#the-lib-file", "title": "The .lib file", "section": "Libraries and Imports", "excerpt": "The .lib is the public interface to a library: its name and version, where its .so is, and a table of contents of every exported function's signature.", "keywords": [ "the", "lib", "file", "the-lib-file", "so", "see", "shared", "output-stem", "library", "name", "version", "ver", "location", "path", "lib-path", "table", "of", "contents", "number", "float", "text", "boolean", "list", "map", "buffer", "time", "timer", "value", "void", "returning", "unknown", "called", "out", "type", "return" ] }, { "slug": "consuming-a-library", "url": "/docs/libraries-and-imports/#consuming-a-library", "title": "Consuming a library", "section": "Libraries and Imports", "excerpt": "That is the whole consumer build — no --link, no -l, no -L.", "keywords": [ "consuming", "library", "consuming-a-library", "link", "see", "lib", "so" ] }, { "slug": "several-libraries-in-one-so", "url": "/docs/libraries-and-imports/#several-libraries-in-one-so", "title": "Several libraries in one .so", "section": "Libraries and Imports", "excerpt": "vox a.vox b.vox --shared -o lib.so links several libraries into one .so in a single step — you cannot append to a linked .so, so one link step is the only way to combine them.", "keywords": [ "several", "libraries", "in", "one", "so", "several-libraries-in-one-so", "vox", "a.vox", "b.vox", "shared", "lib.so", "mathkit_1_0_add_two_numbers", "mathkit_2_0_add_two_numbers", "library", "version" ] }, { "slug": "mangling", "url": "/docs/libraries-and-imports/#mangling", "title": "Mangling", "section": "Libraries and Imports", "excerpt": "Every exported function is mangled to a single flat label:", "keywords": [ "mangling", "mathkit", "1.0", "add", "two", "numbers", "mathkit_1_0_add_two_numbers", "a-za-z0-9_", "1_0", "mathkit__1_0_add_two_numbers", "so" ] }, { "slug": "calling-a-library-from-a-non-vox-host", "url": "/docs/libraries-and-imports/#calling-a-library-from-a-non-vox-host", "title": "Calling a library from a non-Vox host", "section": "Libraries and Imports", "excerpt": "A shared library is a plain .so, so any caller that can link one can use it — C, Rust, or hand-written assembly.", "keywords": [ "calling", "library", "from", "non-vox", "host", "calling-a-library-from-a-non-vox-host", "so", "examples" ] }, { "slug": "linking-an-executable-against-a-so-directly", "url": "/docs/libraries-and-imports/#linking-an-executable-against-a-so-directly", "title": "Linking an executable against a .so directly", "section": "Libraries and Imports", "excerpt": "If the library has a .lib, you do not need this: see it, which registers its signatures and links its .so. --link is for a .so with no .lib — foreign, or hand-built — where the compiler knows no Vox…", "keywords": [ "linking", "an", "executable", "against", "so", "directly", "linking-an-executable-against-a-so-directly", "lib", "see", "link", "libmath.so", "math" ] }, { "slug": "compiler-usage", "url": "/docs/compiler-usage/", "title": "Compiler Usage", "section": "Compiler Usage", "excerpt": "Covers Basic Usage (Compiler Invocation), Options and Examples.", "keywords": [ "compiler", "usage", "compiler-usage" ] }, { "slug": "basic-usage-compiler-invocation", "url": "/docs/compiler-usage/#basic-usage-compiler-invocation", "title": "Basic Usage (Compiler Invocation)", "section": "Compiler Usage", "excerpt": "", "keywords": [ "basic", "usage", "compiler", "invocation", "basic-usage-compiler-invocation" ] }, { "slug": "options", "url": "/docs/compiler-usage/#options", "title": "Options", "section": "Compiler Usage", "excerpt": "", "keywords": [ "options", "emit-asm", "run", "shared", "link", "libs", "lib", "see", "lib-path", "paths", "file", "verbose" ] }, { "slug": "examples", "url": "/docs/compiler-usage/#examples", "title": "Examples", "section": "Compiler Usage", "excerpt": "", "keywords": [ "examples" ] }, { "slug": "grammar-summary", "url": "/docs/grammar-summary/", "title": "Grammar Summary", "section": "Grammar Summary", "excerpt": "", "keywords": [ "grammar", "summary", "grammar-summary" ] } ] }