use grw::graph::{self, Graph, edge}; // path: 0 — 1 — 2 (grouping builds a chain) let g: Graph<(), edge::Undir<()>> = graph![ N(0) ^ (N(1) ^ N(2)) ].unwrap();
// triangle: chain + back-reference closes the cycle let g: Graph<(), edge::Undir<()>> = graph![ N(0) ^ (N(1) ^ (N(2) ^ n(0))) ].unwrap();
// star: flat chaining fans out from one node let g: Graph<(), edge::Undir<()>> = graph![ N(0) ^ N(1) ^ N(2) ^ N(3) ^ N(4) ].unwrap();

// with node values
let g: Graph<&str, edge::Undir<()>> = graph![
    N(0).val("alice") ^ (N(1).val("bob") ^ N(2).val("carol"))
].unwrap();

// with edge values — use & E().val(...) before the direction operator
let g: Graph<(), edge::Undir<f64>> = graph![
    N(0) & E().val(1.5) ^ (N(1) & E().val(2.0) ^ N(2))
].unwrap();

// both node and edge values
let g: Graph<&str, edge::Undir<u32>> = graph![
    N(0).val("a") & E().val(10) ^ N(1).val("b")
].unwrap();

// anonymous nodes — ids assigned automatically
let g: Graph<(), edge::Undir<()>> = graph![N_() ^ N_() ^ N_()].unwrap();

// path: 0 → 1 → 2 (grouping builds a chain) let g: Graph<(), edge::Dir<()>> = graph![ N(0) >> (N(1) >> N(2)) ].unwrap();
// fan-out: flat chaining from one node let g: Graph<(), edge::Dir<()>> = graph![ N(0) >> N(1) >> N(2) >> N(3) ].unwrap();
// bidirectional: n() references existing nodes let g: Graph<(), edge::Dir<()>> = graph![ N(0) >> N(1), n(1) >> n(0), ].unwrap();

// incoming edges with <<
let g: Graph<(), edge::Dir<()>> = graph![
    N(0) << N(1),   // edge from 1 to 0
].unwrap();

// directed with edge values
let g: Graph<(), edge::Dir<i32>> = graph![
    N(0) & E().val(10) >> (N(1) & E().val(20) >> N(2))
].unwrap();

When the type can't be inferred, use the turbofish form:

let g = graph![<(), grw::graph::edge::Undir<()>>; N(0) ^ N(1)].unwrap();

The returned Modification contains:

• new_node_ids — mapping from local ids to real graph ids
• added_edges — edges created
• removed_nodes / removed_edges — what was deleted
• swapped_node_vals / swapped_edge_vals — old values that were replaced

When search! receives a graph reference, it creates a Session that you iterate directly with a for loop:

use grw::*;           // Graph, graph!, search!, Morphism, etc.
use grw::graph::edge;

// target graph: triangle 0—1—2—0
let g: graph::Undir0 = graph![
    N(0) ^ (N(1) ^ (N(2) ^ n(0)))
].unwrap();

// search! with a graph reference → Session → for loop
let session = search![&g,
    get(Mono) {
        N(0) ^ N(1)
    }
].unwrap();

for m in &session {
    let a = m.get(0).unwrap();   // graph node matched by pattern node 0
    let b = m.get(1).unwrap();   // graph node matched by pattern node 1
    println!("{:?} — {:?}", a, b);
}

Each iteration yields a Match — a mapping from pattern node local ids to graph node ids.

let session = search![&g, get(Mono) { N(0) ^ N(1) }].unwrap();

for m in &session {
    // get a specific pattern node's graph mapping
    let node_id: id::N = m.get(0).unwrap();

    // iterate all (pattern_local_id, graph_node_id) pairs
    for &(lid, nid) in m.iter() {
        println!("pattern {} → graph {:?}", lid.0, nid);
    }

    // just the graph node ids
    let graph_nodes: Vec<id::N> = m.values().collect();
}

For richer access — node values, adjacencies — use translate():

for m in &session {
    let tm = session.translate(&m);

    // node with its value
    if let Some((nid, val)) = tm.node(0) {
        println!("pattern 0 → graph {:?} val={:?}", nid, val);
    }

    // all matched nodes with values
    for (lid, nid, val) in tm.nodes() {
        println!("{} → {:?} = {:?}", lid.0, nid, val);
    }
}

// find edges whose endpoints do NOT share a common neighbor
let session = search![&g,
    get(Mono) {
        N(0) ^ N(1)
    },
    ban(Mono) {
        n(0) ^ N(2),
        n(1) ^ n(2),
    }
].unwrap();

The Session returned by search![&g, ...] supports two iteration modes:

// sequential — lazy iterator, one match at a time (backtracking)
for m in session.iter() { /* ... */ }

// parallel — uses rayon, returns all matches at once
let all_matches: Vec<Match> = session.par_iter().collect();

session.iter() (or &session in a for loop) is Seq — single-threaded lazy backtracking. session.par_iter() is Par — partitions the search space across threads via rayon.

When using search![&g, ...], the graph is indexed automatically with RevCsr. For manual control, you can index explicitly and use the lower-level Seq::search / Par::search API:

use grw::search::{Search, Seq, Par, RevCsr};

let Search::Resolved(r) = search![<(), edge::Undir<()>>;
    get(Mono) { N(0) ^ N(1) }
].unwrap() else { panic!() };

let indexed = g.index(RevCsr);

// low-level sequential
let matches: Vec<_> = Seq::search(&r.query, &indexed).collect();

// low-level parallel
let matches: Vec<_> = Par::search(&r.query, &indexed);

These form a partial order. Going up adds constraints, going down relaxes them. The meet() of two morphisms is the most relaxed morphism that satisfies both.

         Iso
        /   \
    SubIso  EpiMono
       \   / \   /
        Mono   Epi
          \   /
           Homo

• Up = more constrained, down = more relaxed
• SubIso = Mono + induced, EpiMono = Mono + surjective
• Iso = SubIso + surjective = EpiMono + induced

• Iso — "Are these two graphs identical?" Graph comparison, canonical forms, symmetry detection.
• SubIso — "Does this shape appear inside that graph?" The workhorse of pattern matching. Find motifs, substructures, embedded patterns. The matched region must look exactly like the pattern — no extra connections.
• Mono — "Can I embed this pattern without node conflicts?" Like SubIso but relaxed: extra edges between matched nodes are allowed. Often easier to compute.
• Epi — "Does the pattern cover the entire target?" Every target node must be matched. Coverage analysis, tiling.
• EpiMono — "Is this a relabeling with possible extra edges?" Bijective but non-induced. Arises naturally when combining Mono and Epi constraints.
• Homo — "Can this pattern be projected onto that graph?" Most relaxed. Graph coloring is a homomorphism to a complete graph.

Pattern: path A — B — C. Target: triangle 0 — 1 — 2 — 0.

Pattern

Target

Mapping A→0, B→1, C→2 — the required edges (A—B, B—C) are present, but there's an extra edge 0—2 not in the pattern:

Mono: accept extra edge OK — not induced

SubIso: reject extra edge violates induced constraint

Collapsing A→0, B→1, C→1 — C maps to the same target node as B:

Homo: accept collapse allowed

Mono: reject — B and C map to same node (not injective)

In practice, real-world graphs have structure (bounded degree, sparsity, value predicates) that makes these tractable with backtracking and pruning. Small patterns on large graphs are fast.