🥮 mooncakes.io
    Sign in

    moonrockz/diagrams/railroad-trace does not have a README file

    RailroadTraceProvider

    source
    pub(open) trait RailroadTraceProvider {
      fn trace(Self, TraceRequest) -> TraceResult
    }

    A publicly implementable hook for an external regex matcher or grammar parser. This library bundles no implementation. A provider that supports one subject kind returns Unsupported for the other.

    Attempt

    source
    pub struct Attempt {
      id : String
      status : AttemptStatus
      steps : ReadOnlyArray[Step]
      failure : FailurePoint?
      continuous : Bool
      label : String?
    } derive(Eq, 
    Debug    )

    One finite attempt of an external engine. Repeated or backtracked steps stay separate, even when they reuse a term or connector.

    Attempt::equal

    source
    fn Attempt::equal(Attempt, Attempt) -> Bool

    Attempt::new

    source
    fn Attempt::new(id : String, status : AttemptStatus, steps : ArrayView[Step], failure? : FailurePoint, continuous? : Bool, label? : String) -> Attempt

    Attempt::not_equal

    source
    fn Attempt::not_equal(x : Attempt, y : Attempt) -> Bool

    Attempt::to_repr

    source

    AttemptStatus

    source
    pub(all) enum AttemptStatus {
      Matched
      NotMatched
    } derive(Eq, 
    Debug    )

    AttemptStatus::equal

    source

    AttemptStatus::not_equal

    source
    fn AttemptStatus::not_equal(x : AttemptStatus, y : AttemptStatus) -> Bool

    AttemptStatus::to_repr

    source

    Connector

    source
    pub struct Connector {
      id : String
      owner : String
      role : ConnectorRole
      from : String
      to : String
      rule : String
      constraint : Bool
    } derive(Eq, 
    Debug    )

    One drawn connector between two points, in its semantic direction.

    Connector::equal

    source
    fn Connector::equal(Connector, Connector) -> Bool

    Connector::not_equal

    source
    fn Connector::not_equal(x : Connector, y : Connector) -> Bool

    Connector::to_repr

    source

    ConnectorRole

    source
    pub(all) enum ConnectorRole {
      Start
      End
      Gap
      Split(Int)
      Join(Int)
      Enter
      Leave
      Bypass
      Return
      Empty
    } derive(Eq, 
    Debug    )

    The structural role of a drawn connector.

    ConnectorRole::equal

    source

    ConnectorRole::name

    source
    fn ConnectorRole::name(self : ConnectorRole) -> String

    ConnectorRole::not_equal

    source
    fn ConnectorRole::not_equal(x : ConnectorRole, y : ConnectorRole) -> Bool

    ConnectorRole::to_repr

    source

    FailurePoint

    source
    pub struct FailurePoint {
      target : FailureTarget
      position : Int?
      message : String?
    } derive(Eq, 
    Debug    )

    FailurePoint::equal

    source

    FailurePoint::new

    source
    fn FailurePoint::new(target : FailureTarget, position? : Int, message? : String) -> FailurePoint

    FailurePoint::not_equal

    source
    fn FailurePoint::not_equal(x : FailurePoint, y : FailurePoint) -> Bool

    FailurePoint::to_repr

    source

    FailureTarget

    source
    pub(all) enum FailureTarget {
      Terminal(String)
      Assertion(String)
      Entry(String)
      Exit(String)
    } derive(Eq, 
    Debug    )

    The place where an attempt failed.

    FailureTarget::equal

    source

    FailureTarget::not_equal

    source
    fn FailureTarget::not_equal(x : FailureTarget, y : FailureTarget) -> Bool

    FailureTarget::to_repr

    source

    InputSpan

    source
    pub struct InputSpan {
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    A half-open UTF-16 span of the input.

    InputSpan::equal

    source
    fn InputSpan::equal(InputSpan, InputSpan) -> Bool

    InputSpan::new

    source
    fn InputSpan::new(start : Int, end : Int) -> InputSpan

    InputSpan::not_equal

    source
    fn InputSpan::not_equal(x : InputSpan, y : InputSpan) -> Bool

    InputSpan::to_repr

    source

    Step

    source
    pub(all) enum Step {
      Visit(String, InputSpan?)
      Traverse(String, Bool)
    } derive(Eq, 
    Debug    )

    One oriented trace step. A visit passes through a term from its entry to its exit. A traversal follows a drawn connector, forward or reversed.

    Step::equal

    source
    fn Step::equal(Step, Step) -> Bool

    Step::not_equal

    source
    fn Step::not_equal(x : Step, y : Step) -> Bool

    Step::to_repr

    source

    Subject

    source

    The typed subject of a trace request. An EBNF subject names its start rule by rule identity.

    Subject::equal

    source
    fn Subject::equal(Subject, Subject) -> Bool

    Subject::fingerprint

    source
    fn Subject::fingerprint(self : Subject) -> String

    The fingerprint of the structure of a subject. A trace for an edited or different model has a different fingerprint, even with equal identities.

    Subject::identity

    source
    fn Subject::identity(self : Subject, view_id? : String) -> SubjectIdentity

    Subject::kind

    source
    fn Subject::kind(self : Subject) -> SubjectKind

    Subject::model_id

    source
    fn Subject::model_id(self : Subject) -> String

    Subject::not_equal

    source
    fn Subject::not_equal(x : Subject, y : Subject) -> Bool

    Subject::to_repr

    source

    SubjectIdentity

    source
    pub struct SubjectIdentity {
      kind : SubjectKind
      model_id : String
      view_id : String
      fingerprint : String
      start_rule : String?
    } derive(Eq, 
    Debug    )

    The provenance of a trace: subject kind, model and view identity and the structural fingerprint of the model.

    SubjectIdentity::equal

    source

    SubjectIdentity::not_equal

    source
    fn SubjectIdentity::not_equal(x : SubjectIdentity, y : SubjectIdentity) -> Bool

    SubjectIdentity::to_repr

    source

    SubjectKind

    source
    pub(all) enum SubjectKind {
      Regex
      Ebnf
    } derive(Eq, 
    Debug    )

    The two railroad subject kinds.

    SubjectKind::equal

    source
    fn SubjectKind::equal(SubjectKind, SubjectKind) -> Bool

    SubjectKind::not_equal

    source
    fn SubjectKind::not_equal(x : SubjectKind, y : SubjectKind) -> Bool

    SubjectKind::to_repr

    source

    Term

    source
    pub struct Term {
      id : String
      kind : TermKind
      label : String
      rule : String
      constraint : Bool
      entry : String
      exit : String
    } derive(Eq, 
    Debug    )

    One visible term occurrence. Equal labels in different positions have different identities.

    Term::equal

    source
    fn Term::equal(Term, Term) -> Bool

    Term::not_equal

    source
    fn Term::not_equal(x : Term, y : Term) -> Bool

    Term::to_repr

    source

    TermKind

    source
    pub(all) enum TermKind {
      Consumed
      Reference(
    Resolution    )
      Anchor
      Assertion
      Empty
    } derive(Eq, 
    Debug    )

    The role of one visible term. Terms are visit targets.

    TermKind::equal

    source
    fn TermKind::equal(TermKind, TermKind) -> Bool

    TermKind::not_equal

    source
    fn TermKind::not_equal(x : TermKind, y : TermKind) -> Bool

    TermKind::to_repr

    source

    Topology

    source
    pub struct Topology {
      kind : SubjectKind
      model_id : String
      fingerprint : String
      tracks : ReadOnlyArray[Track]
      terms : ReadOnlyArray[Term]
      connectors : ReadOnlyArray[Connector]
      walk : ReadOnlyArray[Step]
      // private fields
    }

    The semantic railroad topology of a model: visible terms, points and drawn connectors. External engines map their events to these identities before any SVG or animation exists.

    Topology::connector

    source
    fn Topology::connector(self : Topology, id : String) -> Connector?

    Topology::connector_between

    source
    fn Topology::connector_between(self : Topology, from : String, to : String) -> Connector?

    The connector between two points, if one is drawn.

    Topology::connector_of

    source
    fn Topology::connector_of(self : Topology, owner : String, role : ConnectorRole) -> Connector?

    The connector with role that owner draws, if any.

    Topology::connectors_from

    source
    fn Topology::connectors_from(self : Topology, point : String) -> Array[Connector]

    The connectors that leave point, in drawing order.

    Topology::ebnf

    source

    Build the topology of a grammar. Each rule is one track. References are terms; no connector joins two rules.

    Topology::entry

    source
    fn Topology::entry(self : Topology, id : String) -> String?

    The entry point of a node, rule or model identity.

    Topology::exit

    source
    fn Topology::exit(self : Topology, id : String) -> String?

    The exit point of a node, rule or model identity.

    Topology::has_point

    source
    fn Topology::has_point(self : Topology, point : String) -> Bool

    Topology::regex

    source

    Build the topology of a regex model. The pattern is one track whose identity is the model identity.

    Topology::term

    source
    fn Topology::term(self : Topology, id : String) -> Term?

    TopologyResult

    source
    pub struct TopologyResult {
      topology : Topology?
      diagnostics : ReadOnlyArray[
    Diagnostic    ]
    }

    Trace

    source
    pub struct Trace {
      subject : SubjectIdentity
      input : String
      provider : String
      attempts : ReadOnlyArray[Attempt]
    } derive(Eq, 
    Debug    )

    Immutable evidence that an external engine supplied. It is separate from the diagram and is never computed by this library.

    Trace::equal

    source
    fn Trace::equal(Trace, Trace) -> Bool

    Trace::new

    source
    fn Trace::new(request : TraceRequest, provider : String, attempts : ArrayView[Attempt]) -> Trace

    Make a trace bound to the subject of request.

    Trace::not_equal

    source
    fn Trace::not_equal(x : Trace, y : Trace) -> Bool

    Trace::to_repr

    source

    TraceLimits

    source
    pub struct TraceLimits {
      input : Int
      attempts : Int
      steps : Int
      depth : Int
      work : Int
    } derive(Eq, 
    Debug    )

    Explicit trace bounds. Providers honor them cooperatively; validation enforces them for every supplied trace.

    TraceLimits::equal

    source
    fn TraceLimits::equal(TraceLimits, TraceLimits) -> Bool

    TraceLimits::new

    source
    fn TraceLimits::new(input? : Int, attempts? : Int, steps? : Int, depth? : Int, work? : Int) -> TraceLimits

    TraceLimits::not_equal

    source
    fn TraceLimits::not_equal(x : TraceLimits, y : TraceLimits) -> Bool

    TraceLimits::to_repr

    source

    TraceLimits::valid

    source
    fn TraceLimits::valid(self : TraceLimits) -> Bool

    TraceRequest

    source
    pub struct TraceRequest {
      subject : Subject
      view_id : String
      input : String
      limits : TraceLimits
    } derive(Eq, 
    Debug    )

    One immutable request to an external matching or parsing engine.

    TraceRequest::ebnf

    source
    fn TraceRequest::ebnf(grammar : 
    Grammar    , start_rule : String, input : String, view_id? : String, limits? : TraceLimits) -> TraceRequest

    TraceRequest::equal

    source

    TraceRequest::identity

    source
    fn TraceRequest::identity(self : TraceRequest) -> SubjectIdentity

    The provenance that a trace for this request must carry.

    TraceRequest::not_equal

    source
    fn TraceRequest::not_equal(x : TraceRequest, y : TraceRequest) -> Bool

    TraceRequest::regex

    source
    fn TraceRequest::regex(model : 
    Regex    , input : String, view_id? : String, limits? : TraceLimits) -> TraceRequest

    TraceRequest::to_repr

    source

    TraceRequest::topology

    source
    fn TraceRequest::topology(self : TraceRequest) -> TopologyResult

    The semantic topology of the requested subject, for mapping engine events.

    TraceRequest::validate

    source

    Check a request before a provider receives it.

    TraceResult

    source
    pub(all) enum TraceResult {
      Matched(Trace)
      NotMatched(Trace)
      Unsupported(String)
      Exhausted(String)
      ProviderError(String)
    } derive(Eq, 
    Debug    )

    The outcome of a provider. Unsupported, exhausted and error results are not evidence of a non-match.

    TraceResult::equal

    source
    fn TraceResult::equal(TraceResult, TraceResult) -> Bool

    TraceResult::not_equal

    source
    fn TraceResult::not_equal(x : TraceResult, y : TraceResult) -> Bool

    TraceResult::to_repr

    source

    TraceRun

    source
    pub struct TraceRun {
      result : TraceResult?
      validated : ValidatedTrace?
      diagnostics : ReadOnlyArray[
    Diagnostic    ]
    }

    The result of an explicit provider run.

    TraceRun::refused

    source

    A run that did not reach a provider, with the reasons.

    TraceValidation

    source
    pub struct TraceValidation {
      validated : ValidatedTrace?
      diagnostics : ReadOnlyArray[
    Diagnostic    ]
    }

    Track

    source
    pub struct Track {
      id : String
      name : String
      start : String
      end : String
    } derive(Eq, 
    Debug    )

    One rule, or the single pattern of a regex, with its boundary points.

    Track::equal

    source
    fn Track::equal(Track, Track) -> Bool

    Track::not_equal

    source
    fn Track::not_equal(x : Track, y : Track) -> Bool

    Track::to_repr

    source

    ValidatedTrace

    source
    pub struct ValidatedTrace {
      trace : Trace
      topology : Topology
    }

    A trace that passed structural validation against one subject, with the topology it refers to. Validation never re-runs or verifies matching.

    connector_id

    source
    fn connector_id(owner : String, role : ConnectorRole) -> String

    The stable identity of the connector that owner draws with role.

    diagnostic_codes

    source
    let diagnostic_codes : ReadOnlyArray[String]

    The stable diagnostic codes of trace validation and the provider driver.

    point_id

    source
    fn point_id(owner : String, side : String) -> String

    The stable identity of a point. Identities are length-prefixed, so a node identity that contains : cannot collide with another point.

    run

    source
    fn[P : RailroadTraceProvider] run(provider : P, request : TraceRequest) -> TraceRun

    Invoke provider once for request and validate its result. This is the only library entry point that calls a provider.

    validate_result

    source
    fn validate_result(result : TraceResult, subject : Subject, view_id? : String, limits? : TraceLimits) -> TraceValidation

    Validate a provider result. A matched result needs a matched attempt; a non-match result has none.

    validate_trace

    source
    fn validate_trace(trace : Trace, subject : Subject, view_id? : String, limits? : TraceLimits) -> TraceValidation

    Validate supplied evidence: subject kind, model/view identity, structural fingerprint, targets, roles, declared continuity, spans and bounds. It reports invalid evidence without guessing targets from labels.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io