Struct EmptySubject 

pub struct EmptySubject(pub Subject);

Newtype wrapper for “empty” combination strategy that creates anonymous subjects.

When combining two EmptySubject instances, the result is always an anonymous subject with no labels or properties. This serves as the identity element for a Monoid-like structure.

Semigroup Laws

This satisfies associativity trivially: empty(empty(a, b), c) = empty(a, empty(b, c)) = empty

Monoid Laws

When used with Default, this provides monoid identity:

• Left identity: empty.combine(s) = empty
• Right identity: s.combine(empty) = empty

Examples

use pattern_core::{Subject, Symbol, Combinable, EmptySubject};
use std::collections::HashSet;

let s1 = EmptySubject(Subject {
    identity: Symbol("alice".to_string()),
    labels: {
        let mut s = HashSet::new();
        s.insert("Person".to_string());
        s
    },
    properties: Default::default(),
});

let empty = EmptySubject(Subject {
    identity: Symbol("_".to_string()),
    labels: HashSet::new(),
    properties: Default::default(),
});

// Always returns empty (anonymous)
let result = s1.combine(empty);
assert_eq!(result.0.identity.0, "_");
assert!(result.0.labels.is_empty());

Tuple Fields

0: Subject

Trait Implementations

impl Clone for EmptySubject

fn clone(&self) -> EmptySubject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Combinable for EmptySubject

fn combine(self, _other: Self) -> Self

Combines two values associatively.

impl Default for EmptySubject

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for EmptySubject

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