moonrockz/diagrams/regex

README
- ::equalDiagnostic::equal
- ::errorDiagnostic::error
- ::not_equalDiagnostic::not_equal
- ::to_reprDiagnostic::to_repr
- ::warningDiagnostic::warning
- ::equalPosition::equal
- ::not_equalPosition::not_equal
- ::to_reprPosition::to_repr
- ::equalSeverity::equal
- ::not_equalSeverity::not_equal
- ::to_reprSeverity::to_repr
- ::equalSpan::equal
- ::not_equalSpan::not_equal
- ::to_reprSpan::to_repr
V
version

moonrockz/diagrams/regex does not have a README file

AnchorKind

pub(all) enum AnchorKind {
  LineStart
  LineEnd
  InputStart
  InputEndBeforeNewline
  InputEnd
  PreviousMatchEnd
  WordBoundary
  NonWordBoundary
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A zero-width position test that consumes no input.

AnchorKind::equal

source

fn AnchorKind::equal(AnchorKind, AnchorKind) -> Bool

AnchorKind::not_equal

source

fn AnchorKind::not_equal(x : AnchorKind, y : AnchorKind) -> Bool

AnchorKind::to_repr

source

fn AnchorKind::to_repr(AnchorKind) -> @moonbitlang/core/debug.Repr
Repr

Bounds

source

pub struct Bounds {
  min : Int
  max : Int?
  reluctant : Bool
  spelling : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Symbolic repetition bounds. A repeat is never expanded into copies.

Bounds::equal

source

fn Bounds::equal(Bounds, Bounds) -> Bool

Bounds::new

source

fn Bounds::new(min : Int, max? : Int, reluctant? : Bool, spelling? : String) -> Bounds

Make bounds. The spelling defaults to the canonical regex quantifier.

Bounds::not_equal

source

fn Bounds::not_equal(x : Bounds, y : Bounds) -> Bool

Bounds::to_repr

source

fn Bounds::to_repr(Bounds) -> @moonbitlang/core/debug.Repr
Repr

ClassKind

source

pub(all) enum ClassKind {
  Any
  Shorthand(Char)
  Property(String)
  CodePoint(String)
  Posix(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A predefined character class. The spelling is kept for display.

ClassKind::equal

source

fn ClassKind::equal(ClassKind, ClassKind) -> Bool

ClassKind::not_equal

source

fn ClassKind::not_equal(x : ClassKind, y : ClassKind) -> Bool

ClassKind::to_repr

source

fn ClassKind::to_repr(ClassKind) -> @moonbitlang/core/debug.Repr
Repr

GroupKind

source

pub(all) enum GroupKind {
  Capturing
  NonCapturing
  Named(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

GroupKind::equal

source

fn GroupKind::equal(GroupKind, GroupKind) -> Bool

GroupKind::not_equal

source

fn GroupKind::not_equal(x : GroupKind, y : GroupKind) -> Bool

GroupKind::to_repr

source

fn GroupKind::to_repr(GroupKind) -> @moonbitlang/core/debug.Repr
Repr

Index

source

pub struct Index {
  regex : Regex
  order : ReadOnlyArray[String]
  // private fields
}

A validated view of a regex model with constant-time lookups. Every node except the root has exactly one parent, so the arena is a finite tree.

Index::build

source

fn Index::build(regex : Regex, limits? : Limits) -> IndexResult

Validate identities, ownership, bounds and explicit limits without recursion.

Index::depth

source

fn Index::depth(self : Index, id : String) -> Int?

Index::node

source

fn Index::node(self : Index, id : String) -> Node?

Index::parent

source

fn Index::parent(self : Index, id : String) -> String?

IndexResult

source

pub struct IndexResult {
  index : Index?
  diagnostics : ReadOnlyArray[@moonrockz/diagrams.Diagnostic
Diagnostic]
}

Kind

source

pub(all) enum Kind {
  Literal(String)
  Class(ClassKind)
  Set(Bool, ReadOnlyArray[SetItem])
  Anchor(AnchorKind)
  Backreference(String)
  Sequence(ReadOnlyArray[String])
  Choice(ReadOnlyArray[String])
  Group(GroupKind, String)
  Repeat(Bounds, String)
  Assertion(Look, Bool, String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The meaning of one expression node. Composite kinds name their children by node identity, so a model is a flat, bounded arena.

Kind::equal

source

fn Kind::equal(Kind, Kind) -> Bool

Kind::not_equal

source

fn Kind::not_equal(x : Kind, y : Kind) -> Bool

Kind::to_repr

source

fn Kind::to_repr(Kind) -> @moonbitlang/core/debug.Repr
Repr

Limits

source

pub struct Limits {
  nodes : Int
  depth : Int
  work : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Explicit bounds for model validation and indexing.

Limits::equal

source

fn Limits::equal(Limits, Limits) -> Bool

Limits::new

source

fn Limits::new(nodes? : Int, depth? : Int, work? : Int) -> Limits

Limits::not_equal

source

fn Limits::not_equal(x : Limits, y : Limits) -> Bool

Limits::to_repr

source

fn Limits::to_repr(Limits) -> @moonbitlang/core/debug.Repr
Repr

Look

source

pub(all) enum Look {
  Ahead
  Behind
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The direction of a lookaround assertion.

Look::equal

source

fn Look::equal(Look, Look) -> Bool

Look::not_equal

source

fn Look::not_equal(x : Look, y : Look) -> Bool

Look::to_repr

source

fn Look::to_repr(Look) -> @moonbitlang/core/debug.Repr
Repr

Node

source

pub struct Node {
  id : String
  kind : Kind
  source : @moonrockz/diagrams.Span
Span?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Node::children

source

fn Node::children(self : Node) -> ReadOnlyArray[String]

The children of node in drawing order.

Node::equal

source

fn Node::equal(Node, Node) -> Bool

Node::is_leaf

source

fn Node::is_leaf(self : Node) -> Bool

Literal text, classes, sets and anchors are leaves of the railroad.

Node::label

source

fn Node::label(self : Node) -> String

The visible label of a leaf, or the name of a composite construct.

Node::new

source

fn Node::new(id : String, kind : Kind, source? : @moonrockz/diagrams.Span
Span) -> Node

Node::not_equal

source

fn Node::not_equal(x : Node, y : Node) -> Bool

Node::to_repr

source

fn Node::to_repr(Node) -> @moonbitlang/core/debug.Repr
Repr

Regex

source

pub struct Regex {
  id : String
  root : String
  nodes : ReadOnlyArray[Node]
  title : String?
  accessibility_title : String?
  accessibility_description : String?
  pattern : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One immutable regular-expression diagram. It describes the structure of a pattern; it does not match input.

Regex::equal

source

fn Regex::equal(Regex, Regex) -> Bool

Regex::new

source

fn Regex::new(id : String, root : String, nodes : ArrayView[Node], title? : String, accessibility_title? : String, accessibility_description? : String, pattern? : String) -> Regex

Make a regex model. pattern is the optional source spelling for display.

Regex::node

source

fn Regex::node(self : Regex, id : String) -> Node?

Find a node by identity. The search is linear; use Index for repeated lookups.

Regex::not_equal

source

fn Regex::not_equal(x : Regex, y : Regex) -> Bool

Regex::to_repr

source

fn Regex::to_repr(Regex) -> @moonbitlang/core/debug.Repr
Repr

SetItem

source

pub(all) enum SetItem {
  Char(String)
  Range(String, String)
  Escape(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One item of a bracketed character set.

SetItem::equal

source

fn SetItem::equal(SetItem, SetItem) -> Bool

SetItem::not_equal

source

fn SetItem::not_equal(x : SetItem, y : SetItem) -> Bool

SetItem::to_repr

source

fn SetItem::to_repr(SetItem) -> @moonbitlang/core/debug.Repr
Repr

diagnostic_codes

source

let diagnostic_codes : ReadOnlyArray[String]

The stable diagnostic codes of model validation.

validate

source

fn validate(regex : Regex, limits? : Limits) -> ReadOnlyArray[@moonrockz/diagrams.Diagnostic
Diagnostic]

Validate a constructed model. An empty result means the model is valid.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#AnchorKind

#AnchorKind::equal

#AnchorKind::not_equal

#AnchorKind::to_repr

#Bounds

#Bounds::equal

#Bounds::new

#Bounds::not_equal

#Bounds::to_repr

#ClassKind

#ClassKind::equal

#ClassKind::not_equal

#ClassKind::to_repr

#GroupKind

#GroupKind::equal

#GroupKind::not_equal

#GroupKind::to_repr

#Index

#Index::build

#Index::depth

#Index::node

#Index::parent

#IndexResult

#Kind

#Kind::equal

#Kind::not_equal

#Kind::to_repr

#Limits

#Limits::equal

#Limits::new

#Limits::not_equal

#Limits::to_repr

#Look

#Look::equal

#Look::not_equal

#Look::to_repr

#Node

#Node::children

#Node::equal

#Node::is_leaf

#Node::label

#Node::new

#Node::not_equal

#Node::to_repr

#Regex

#Regex::equal

#Regex::new

#Regex::node

#Regex::not_equal

#Regex::to_repr

#SetItem

#SetItem::equal

#SetItem::not_equal

#SetItem::to_repr

#diagnostic_codes

#validate

Source Files

AnchorKind

AnchorKind::equal

AnchorKind::not_equal

AnchorKind::to_repr

Bounds

Bounds::equal

Bounds::new

Bounds::not_equal

Bounds::to_repr

ClassKind

ClassKind::equal

ClassKind::not_equal

ClassKind::to_repr

GroupKind

GroupKind::equal

GroupKind::not_equal

GroupKind::to_repr

Index

Index::build

Index::depth

Index::node

Index::parent

IndexResult

Kind

Kind::equal

Kind::not_equal

Kind::to_repr

Limits

Limits::equal

Limits::new

Limits::not_equal

Limits::to_repr

Look

Look::equal

Look::not_equal

Look::to_repr

Node

Node::children

Node::equal

Node::is_leaf

Node::label

Node::new

Node::not_equal

Node::to_repr

Regex

Regex::equal

Regex::new

Regex::node

Regex::not_equal

Regex::to_repr

SetItem

SetItem::equal

SetItem::not_equal

SetItem::to_repr

diagnostic_codes

validate