Struct Frontier 

pub struct Frontier<T> { /* private fields */ }

A progress claim: all timestamps strictly less than some element are complete.

A Frontier is a pure value type — no networking, no I/O, no async.

Implementations

impl<T: PartialOrd + Clone> Frontier<T>

pub fn bottom() -> Self

The identity element for meet — an unconstrained frontier with no elements, where no timestamp is reported in-flight.

pub fn from_elem(t: T) -> Self

Creates a frontier from a single element.

pub fn from_elements(iter: impl IntoIterator<Item = T>) -> Self

Creates a frontier from an iterator of elements.

pub fn less_equal(&self, time: &T) -> bool

Returns true if time is less than or equal to some element of this frontier, meaning time is still in-flight.

pub fn elements(&self) -> &[T]

Returns the underlying antichain elements.

pub fn meet(&self, other: &Self) -> Self

Coordinator-free merge: the most conservative frontier dominated by both.

This is the lattice meet (greatest lower bound): the result is the most advanced frontier that is still less than or equal to both inputs.

Properties proven by the Phase 2 property tests:

• Commutative: meet(a, b) == meet(b, a)
• Associative: meet(a, meet(b, c)) == meet(meet(a, b), c)
• Idempotent: meet(a, a) == a

Convergence guarantee: two nodes that have each seen any subset of the same update set, in any order, will hold identical Frontier values after calling meet for each update.

Performance: O(n²) in antichain width n. For Frontier<u64> (totally ordered), the antichain collapses to width 1, making this effectively O(1). For Frontier<ProductTimestamp<u64, u64>> at worst-case width: 100 ≈ 9 µs, 500 ≈ 204 µs, 1 000 ≈ 825 µs (measured 2026-06-18). Practical production widths are ≤ 50.

use antichain::Frontier;

let f1 = Frontier::from_elem(7u64);
let f2 = Frontier::from_elem(3u64);

// meet returns the more conservative (lower) frontier
let merged = f1.meet(&f2);
assert!(merged.less_equal(&3));   // 3 still in-flight
assert!(!merged.less_equal(&7));  // 7 is past the merged frontier

// order of application does not matter
assert_eq!(f1.meet(&f2), f2.meet(&f1));

impl<T: Lattice + Clone> Frontier<T>

pub fn join(&self, other: &Self) -> Self

Lattice join (least upper bound) — the most advanced frontier dominated by both.

Requires T: Lattice to compute element-wise joins across the two antichains.

Trait Implementations

impl<T: Clone> Clone for Frontier<T>

fn clone(&self) -> Frontier<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Frontier<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Frontier<T>

impl<T: PartialEq> PartialEq for Frontier<T>

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