Struct Parser 

pub struct Parser<'a> { /* private fields */ }

Recursive descent parser for Sigil.

Implementations

impl<'a> Parser<'a>

pub fn new(source: &'a str) -> Self

pub fn parse_file(&mut self) -> ParseResult<SourceFile>

Parse a complete source file.

pub fn parse_expr(&mut self) -> ParseResult<Expr>

Trait Implementations

impl<'a> PluralityParser for Parser<'a>

fn parse_plurality_item(&mut self) -> ParseResult<PluralityItem>

Parse a top-level plurality item

fn parse_alter_def(&mut self, visibility: Visibility) -> ParseResult<AlterDef>

Parse an alter definition

alter Abaddon: Council {
    archetype: Goetia::Abaddon,
    preferred_reality: RealityLayer::Fractured,
    abilities: [...],
    triggers: [...],
    anima: { ... },
    states: { ... }
}

fn parse_headspace_def( &mut self, visibility: Visibility, ) -> ParseResult<HeadspaceDef>

Parse a headspace definition

headspace InnerWorld {
    location Citadel: Sanctuary { ... }
    fn navigate(from: Location, to: Location) -> NavigationResult@? { ... }
}

fn parse_reality_def( &mut self, visibility: Visibility, ) -> ParseResult<RealityDef>

Parse a reality definition

reality entity Church {
    layer Grounded { ... }
    layer Fractured { ... }
    transform Grounded -> Fractured: on perception > 0.5,
}

fn parse_cocon_channel(&mut self) -> ParseResult<CoConChannel>

Parse a co-conscious channel

cocon<Stolas, Paimon> knowledge_share {
    fn share_discovery(info: Knowledge!) -> Acknowledgment~ { ... }
}

fn parse_trigger_handler(&mut self) -> ParseResult<TriggerHandler>

Parse a trigger handler

on trigger ThreatDetected { level: threat } where threat > 0.9 {
    switch! to Abaddon { ... }
}

fn parse_plurality_expr(&mut self) -> ParseResult<PluralityExpr>

Parse a plurality-specific expression

fn parse_alter_block(&mut self) -> ParseResult<AlterBlock>

Parse an alter block (scoped fronting)

alter Abaddon {
    let threat = perceive_entity(enemy);
}

fn parse_switch_expr(&mut self) -> ParseResult<SwitchExpr>

Parse a switch expression

switch to Beleth {
    reason: SwitchReason::TacticalNeed,
    urgency: 0.8,
    then: { ... },
    else: { ... },
}

fn parse_split_expr(&mut self) -> ParseResult<SplitExpr>

Parse a split expression

split! from trauma.primary_holder {
    purpose: SplitPurpose::TraumaHolder,
    memories: inherited_memories(),
    traits: possibly_inverted_traits(),
}

fn parse_alter_sourced_type(&mut self) -> ParseResult<AlterSourcedType>

Parse a type with optional alter-source marker

WorldState@!     // Fronting alter's view
Vec<Voice>@~     // Co-conscious report
Memory@?         // Dormant alter's uncertain memory
State@‽          // Blended paradoxical state

fn parse_alter_expr(&mut self) -> ParseResult<AlterExpr>

Parse an alter expression (reference to an alter)

fn parse_alter_source(&mut self) -> ParseResult<Option<AlterSource>>

Parse an alter-source annotation (@!, @~, @?, @‽, or @AlterName)

fn try_parse_alter_source_marker(&mut self) -> Option<AlterSourceMarker>

Try to parse an alter-source marker if present