Struct AstPattern 

pub struct AstPattern {
    pub subject: AstSubject,
    pub elements: Vec<AstPattern>,
}

Abstract Syntax Tree representation of a Pattern

This is the minimal, language-agnostic output format from pattern-rs. It mirrors the Pattern<Subject> structure exactly.

Structure

• subject: The value of this pattern (identity, labels, properties)
• elements: Child patterns (recursive structure)

Examples

Simple node:

{
  "subject": {
    "identity": "alice",
    "labels": ["Person"],
    "properties": {"name": "Alice"}
  },
  "elements": []
}

Subject pattern with elements:

{
  "subject": {
    "identity": "team",
    "labels": ["Team"],
    "properties": {}
  },
  "elements": [
    {"subject": {"identity": "alice", ...}, "elements": []},
    {"subject": {"identity": "bob", ...}, "elements": []}
  ]
}

Fields

subject: AstSubject

The subject (value) of this pattern

elements: Vec<AstPattern>

Child patterns (elements)

Implementations

impl AstPattern

pub fn empty() -> Self

Create an empty pattern

Useful for representing empty gram files or as a placeholder.

impl AstPattern

pub fn to_pattern(&self) -> Result<Pattern<Subject>, String>

Convert from native Pattern<Subject> to AST

This is the core conversion function that transforms the Rust Pattern structure into a JSON-serializable AST.

Examples

use gram_codec::AstPattern;
use pattern_core::{Pattern, Subject, Symbol};
use std::collections::{HashSet, HashMap};

let subject = Subject {
    identity: Symbol("alice".to_string()),
    labels: HashSet::new(),
    properties: HashMap::new(),
};
let pattern = Pattern::point(subject);
let ast = AstPattern::from_pattern(&pattern);
assert_eq!(ast.subject.identity, "alice");

Convert from AST back to native Pattern<Subject>.

pub fn from_pattern(pattern: &Pattern<Subject>) -> Self

Trait Implementations

impl Clone for AstPattern

fn clone(&self) -> AstPattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AstPattern

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AstPattern

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AstPattern

fn eq(&self, other: &AstPattern) -> 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 Serialize for AstPattern

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AstPattern