Trait RelationView 

pub trait RelationView: FiniteRelation {
    type Tuple<'a>
       where Self: 'a;

    // Required method
    fn tuples(&self) -> impl Iterator<Item = Self::Tuple<'_>>;
}

Shared read-only view for deterministic exact relation iteration. A shared read-only view over a finite exact relation.

RelationView is the first G6 shared convergence boundary. It lets generic code inspect tuple count and iterate over stored tuples in deterministic order across the exact unary, binary, and n-ary relation types.

This first layer intentionally does not cover mutation, membership queries, domain/range inspection, schema access, support materialization, provenance, annotations, temporal support, or backend abstraction. Exact support materialization now lives in the separate G6 capability traits such as crate::ExactSupport and the ToExact*Relation family.

Iteration order follows the deterministic storage order documented by the implementing relation type. Tuple shapes remain concrete:

• unary relations yield &T;
• binary relations yield &(A, B);
• n-ary relations yield &[T].

Examples

use relmath::{FiniteRelation, RelationView, UnaryRelation};

let values = UnaryRelation::from_values([3, 1, 2]);

assert_eq!(values.len(), 3);
assert_eq!(values.tuples().copied().collect::<Vec<_>>(), vec![1, 2, 3]);

Required Associated Types

type Tuple<'a> where Self: 'a

Borrowed tuple item yielded by Self::tuples.

Required Methods

fn tuples(&self) -> impl Iterator<Item = Self::Tuple<'_>>

Returns the stored tuples in deterministic order.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<A: Ord, B: Ord> RelationView for BinaryRelation<A, B>

type Tuple<'a> = &'a (A, B) where Self: 'a

impl<T: Ord> RelationView for NaryRelation<T>

type Tuple<'a> = &'a [T] where Self: 'a

impl<T: Ord> RelationView for UnaryRelation<T>

type Tuple<'a> = &'a T where Self: 'a