Enum Rule 

pub enum Rule {
    EOI,
    WHITESPACE,
    COMMENT,
    file,
    use_decl,
    module_decl,
    doc_block,
    doc_line,
    top_level_item,
    test_decl,
    given_block,
    given_binding,
    entity_constructor,
    constructor_field,
    when_block,
    then_block,
    then_fails,
    then_asserts,
    entity_decl,
    field_decl,
    action_decl,
    action_doc,
    param_decl,
    requires_block,
    ensures_block,
    ensures_item,
    when_clause,
    properties_block,
    prop_entry,
    prop_value,
    invariant_decl,
    edge_cases_decl,
    edge_rule,
    edge_action,
    type_expr,
    optional_marker,
    union_type,
    base_type,
    list_type,
    set_type,
    map_type,
    parameterized_type,
    type_param,
    simple_type,
    expr,
    implies_expr,
    implies_op,
    or_expr,
    or_op,
    and_expr,
    and_op,
    not_expr,
    not_op,
    cmp_expr,
    cmp_op,
    add_expr,
    add_op,
    primary,
    atom,
    old_expr,
    quantifier_expr,
    quantifier_kw,
    paren_expr,
    call_or_ident,
    call_args,
    call_arg,
    named_arg,
    null_literal,
    bool_literal,
    number_literal,
    string_literal,
    string_inner,
    escape_seq,
    list_literal,
    obj_literal,
    obj_field,
    ident,
    type_ident,
}

Variants

EOI

End-of-input

WHITESPACE

Whitespace: spaces, tabs, carriage returns, newlines. Pest silently consumes these between every pair of tokens in non-atomic rules.

COMMENT

Single-line comments: // to end of line.

file

A complete .intent file: one module declaration, an optional doc block, zero or more use imports, and zero or more top-level items.

use_decl

use ModuleName or use ModuleName.ItemName — import from another module. (SPEC.md § Phase 7: Module Imports)

module_decl

Module declaration — every file begins with module ModuleName. (SPEC.md § Composable Contracts)

doc_block

A documentation block: one or more --- lines of natural language. (SPEC.md § Natural language descriptions via --- doc blocks)

doc_line

A single doc line. Atomic so whitespace handling doesn’t eat the content.

top_level_item

Any top-level declaration that may appear after the module header.

test_decl

test "name" { given { ... } when Action { ... } then { ... } } Defines a test scenario that exercises an action with concrete values.

given_block

given { bindings } — concrete variable bindings for test setup.

given_binding

name = TypeName { field: value, ... } or name = expr — a single test binding.

entity_constructor

TypeName { field: value, ... } — constructs an entity instance with concrete values.

constructor_field

name: expr — a field inside an entity constructor or when block.

when_block

when ActionName { param: value, ... } — the action to invoke.

then_block

then { assertions } or then fails — expected outcome.

then_fails

fails with optional violation kind (e.g. fails precondition).

then_asserts

{ expr* } — assertions to check against new state.

entity_decl

entity EntityName { field* } Defines a domain object with typed fields.

field_decl

field_name: TypeExpr — a named, typed field within an entity.

action_decl

action ActionName { doc? param* requires? ensures? properties? } Defines a behavioral operation with pre/postconditions.

action_doc

Optional doc block inside an action (appears before params).

param_decl

Action parameter — same shape as a field declaration.

requires_block

requires { condition* } — preconditions that must hold before execution. (SPEC.md § requires / ensures — Pre/postcondition blocks)

ensures_block

ensures { postcondition* } — postconditions that must hold after execution. Items can be plain expressions or when condition => consequence. (SPEC.md § requires / ensures, old() references)

ensures_item

A single postcondition: either a conditional when clause or a bare expression.

when_clause

when condition => consequence — conditional postcondition. The condition is parsed as or_expr (stops before =>), so the => is unambiguously the when-separator, not the implies operator.

properties_block

properties { entry* } — declarative behavioral annotations. (SPEC.md § properties — Declarative behavioral annotations)

prop_entry

key: value within a properties block.

prop_value

A property value: an object literal, list literal, string, number, bool, or identifier.

invariant_decl

invariant InvariantName { doc? expr } System-wide constraint that must always hold.

edge_cases_decl

edge_cases { rule* } — explicit handling of boundary conditions.

edge_rule

when condition => action(args) — a single edge case rule. Like when_clause, the condition stops at or_expr to avoid => ambiguity.

edge_action

The right-hand side of an edge rule: a function call like reject(...) or allow(...).

type_expr

Full type expression: a union type optionally followed by ? for optional. Examples: String, Active | Frozen | Closed, DateTime?, List<T>?

optional_marker

? suffix marking a type as optional.

union_type

One or more base types separated by |. A | B | C is a union/enum type.

base_type

A single type: collection generic, parameterized type, or simple named type.

list_type

List<T> — ordered collection.

set_type

Set<T> — unique collection.

map_type

Map<K, V> — key-value collection.

parameterized_type

TypeName(param: value, ...) — parameterized type, e.g. Decimal(precision: 2).

type_param

name: literal inside a parameterized type.

simple_type

A plain named type: UUID, String, Int, Bool, DateTime, Email, CurrencyCode, URL, or any user-defined PascalCase type. Also matches enum variant names like Active, Frozen, Completed.

expr

Top-level expression — starts at the implies precedence level.

implies_expr

a => b — logical implication. Parsed as or_expr ("=>" or_expr)*. (SPEC.md § Operators — Logical: =>)

implies_op

or_expr

a || b — logical OR.

or_op

and_expr

a && b — logical AND. Can span multiple lines (see auth.intent ensures block).

and_op

not_expr

!a — logical NOT (prefix). Can be chained: !!x. Falls through to cmp_expr for non-negated expressions.

not_op

cmp_expr

a == b, a != b, a > b, etc. — comparison (non-associative, at most one operator). (SPEC.md § Operators — Comparison)

cmp_op

add_expr

a + b, a - b — additive arithmetic. Used in postconditions like from.balance == old(from.balance) - amount.

add_op

primary

A primary expression, optionally followed by .field access chains. Putting field access here lets lookup(User, email).status work naturally.

atom

The core of a primary expression — ordered so keywords are tried before ident.

old_expr

old(expr) — reference to pre-execution state. (SPEC.md § old() references)

quantifier_expr

forall x: Type => body or exists x: Type => body — quantified expressions. The body is a full expr, so the quantifier binds everything to its right. (SPEC.md § Quantifiers: forall, exists)

quantifier_kw

paren_expr

Parenthesized sub-expression for explicit grouping.

call_or_ident

Either a function call name(args) or a plain identifier name. The optional ( disambiguates: if present, it’s a call; otherwise, an ident reference. Examples: now(), lookup(User, email), amount, Active.

call_args

Comma-separated call arguments (positional or named).

call_arg

A single argument: either name: expr (named) or expr (positional). Named form is tried first; on failure, falls back to positional.

named_arg

name: expr — a named/keyword argument.

null_literal

null — the null/absent value.

bool_literal

true or false.

number_literal

Numeric literal: integer or decimal. Atomic to prevent whitespace insertion. Examples: 0, 42, 10000.00, -1.

string_literal

String literal: "...". Compound-atomic so inner content is captured.

string_inner

The content between string quotes. Supports escaped quotes via \".

escape_seq

Escape sequences within strings.

list_literal

List literal: [a, b, c].

obj_literal

Object literal: { key: value, ... }. Used in property values.

obj_field

key: value inside an object literal.

ident

A general identifier: snake_case, camelCase, or PascalCase. Keywords are context-sensitive in PEG — they are matched by literal strings in the grammar rules above, so ident never needs to exclude them explicitly.

type_ident

A type-position identifier: must start with an uppercase letter. Used for module names, entity names, action names, type references.

Implementations

impl Rule

pub fn all_rules() -> &'static [Rule]

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Rule

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Rule

fn cmp(&self, other: &Rule) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl Parser<Rule> for IntentParser

fn parse<'i>(rule: Rule, input: &'i str) -> Result<Pairs<'i, Rule>, Error<Rule>>

Parses a &str starting from rule.

impl PartialEq for Rule

fn eq(&self, other: &Rule) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Rule

fn partial_cmp(&self, other: &Rule) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Rule

impl Eq for Rule

impl StructuralPartialEq for Rule