Parse, Format & Pattern¶

Parse¶

Module: Parse — encoding and decoding of structured data formats, and generic tokenization.

Parse uses phantom-typed Value<T> types to track the format of parsed data. Each format has a phantom marker type (Json, Toml, Csv, Tree) that tags the Value at the type level while sharing the same runtime representation. The pattern: creates to decode (returns Value<T>), creates to tag (wraps plain Value as Value<T>), validates to check syntax. Serialization back to strings lives in the Types module as creates string.

Parse also provides a generic Token and Rule system for building custom tokenizers. Define rules as regex patterns with kind tags, then tokenize any source text into a List<Token>.

Value Construction¶

Formats¶

Value Accessors¶

Extract typed data from a Value. For corresponding validators, see Types — Value Validators.

URL¶

Defines a binary Url type for parsed URL components.

Base64¶

CSV¶

RFC 4180-compliant CSV parsing. Returns Value<Csv>. Serialize back to string via Types.string.

Tokenization¶

Defines binary types Token (a text span with position and kind tag) and Rule (a regex pattern paired with a kind integer). Rules are tried in order; longest match wins.

Token accessors (start, end, kind) and string(token) are in the Language module. Characters that match no rule produce tokens with kind -1.

Syntax Trees¶

Parse Prove source into a syntax tree backed by tree-sitter. See the Prove module for tree traversal accessors. Extract source text via Types.string(tree).

Phantom Types¶

Parse defines four phantom marker types used as type parameters for Value<T>:

Plain Value (unparameterized) is compatible with any Value<T> — the phantom type parameter is opt-in.

  Parse creates toml json url tokens rule tag base64 validates url base64
  Parse types Value Toml Json Url Token Rule
  Types creates string
  Table creates table derives keys get types Table

main() Result<Unit, Error>!
from
    source as String = System.file("config.toml")!
    doc as Value<Toml> = Parse.toml(source)!
    root as Table<Value> = table(doc)
    names as List<String> = Table.keys(root)
    System.console("Keys: " + join(names, ", "))

Format¶

Module: Format — string formatting and numeric display.

Padding¶

Number Formatting¶

Time & Date Formatting¶

Format time, date, datetime, and duration values using pattern strings.

Supported patterns: "ISO8601", "%Y-%m-%d", "%H:%M:%S", "%Y-%m-%d %H:%M:%S", "%Hh %Mm %Ss", and other strftime-style patterns.

Formatting (value → string) lives in the Format module:

Parsing (string → value) and validation live in the Parse module:

  Format derives pad_left creates hexadecimal decimal date creates date
  Time creates date types Date

creates format_address(addr Integer) String
from
    Format.pad_left(Format.hexadecimal(addr), 8, '0')

creates format_date(date Date) String
from
    Format.date(date, "%Y-%m-%d")

Pattern¶

Module: Pattern — regular expression matching via POSIX regex.

Defines a binary Match type that holds the matched text, start offset, and end offset.

Matching¶

Transform¶

Match Accessors¶

Note: string(matched Match) for extracting matched text is registered in the Types module as a creates string overload, not in Pattern directly. Use Types.string(match) or just string(match) if Types is imported.

  Pattern validates test derives replace creates search find_all split string start end types Match

derives sanitize(input String) String
requires
    test(input, "[a-zA-Z0-9 ]+")
from
    Pattern.replace(input, " +", " ")