Enum Path 

pub enum Path<V, E> {
    Id(V),
    Seq(NonEmpty<E>),
}

A path in a graph or category.

This definition by cases can be compared with the perhaps more obvious definition:

struct Path<V, E> {
start: V,
end: V, // Optional: more symmetric but also more redundant.
seq: Vec<E>,
}

Not only does the single struct store redundant (hence possibly inconsistent) information when the sequence of edges is nonempty, one will often need to do a case analysis on the edge sequence anyway to determine whether, say, reduce returns a non-null value. Thus, it seems better to reify the two cases in the data structure itself.

Variants

Id(V)

The identity, or empty, path at a vertex.

Seq(NonEmpty<E>)

A nontrivial path, comprising a non-empty vector of consecutive edges.

Implementations

impl Path<ModeApp<QualifiedName>, ModeApp<ModalOp>>

pub fn ob_act(self, ob: ModalOb) -> Result<ModalOb, String>

Acts on an object in a model of a modal theory.

impl Path<ModeApp<QualifiedName>, ModeApp<ModalOp>>

pub fn generator(id: QualifiedName) -> Self

Constructs the object operation for a generator.

pub fn concat(list: List, arity: usize, ob_type: ModalObType) -> Self

Constructs a concatenation operation for a list modality.

pub fn apply(self, m: Modality) -> Self

Applies a modality.

pub fn apply_all(self, iter: impl IntoIterator<Item = Modality> + Clone) -> Self

Applies a sequence of modalities.

impl<V, E> Path<V, E>

pub fn empty(v: V) -> Self

Constructs the empty or identity path.

pub fn single(e: E) -> Self

Constructs a path with a single edge.

pub fn pair(e: E, f: E) -> Self

Constructs a pair of consecutive edges, or path of length 2.

pub fn collect<I>(iter: I) -> Option<Self>

where I: IntoIterator<Item = E>,

Constructs a path from an iterator over edges.

Returns None if the iterator is empty.

pub fn from_vec(vec: Vec<E>) -> Option<Self>

Constructs a path from a vector of edges.

Returns None if the vector is empty.

pub fn repeat_n(v: V, e: E, n: usize) -> Self

where E: Clone,

Constructs a path by repeating an edge n times.

The edge should have the same source and target, namely the first argument.

pub fn len(&self) -> usize

Length of the path.

pub fn is_empty(&self) -> bool

Is the path empty?

pub fn iter(&self) -> impl Iterator<Item = &E>

Iterates over edges in the path, if any.

This method is a one-sided inverse to Path::collect.

pub fn only(self) -> Option<E>

Extracts the unique edge in a path of length 1.

This method is a one-sided inverse to Path::single.

pub fn insert(&mut self, index: usize, edge: E)

Inserts an edge into the path at the given index.

pub fn splice(self, range: Range<usize>, replace_with: Self) -> Self

Splices a path into another path at the given range of indices.

pub fn src(&self, graph: &impl Graph<V = V, E = E>) -> V

where V: Clone,

Source of the path in the given graph.

Assumes that the path is contained in the graph.

pub fn tgt(&self, graph: &impl Graph<V = V, E = E>) -> V

where V: Clone,

Target of the path in the given graph.

Assumes that the path is contained in the graph.

pub fn subpath( &self, graph: &impl Graph<V = V, E = E>, range: Range<usize>, ) -> Self

where V: Eq + Clone, E: Clone,

Extracts a subpath of a path in a graph.

Panics if the range is invalid or an empty subpath would be inconsistent.

pub fn replace_subpath( self, graph: &impl Graph<V = V, E = E>, range: Range<usize>, f: impl FnOnce(Self) -> Self, ) -> Self

where V: Eq + Clone, E: Clone,

Replaces the subpath at the given range with a function of that subpath.

Panics under the same conditions as subpath.

pub fn concat_in( self, graph: &impl Graph<V = V, E = E>, other: Self, ) -> Option<Self>

where V: Eq + Clone,

Concatenates this path with another path in the graph.

This methods checks that the two paths are compatible (the target of this path equals the source of the other path) and it assumes that both paths are contained in the graph, which should be checked with contained_in if in doubt. Thus, when returned, the concatenated path is also a valid path.

pub fn contained_in(&self, graph: &impl Graph<V = V, E = E>) -> bool

where V: Eq,

Is the path contained in the given graph?

pub fn is_simple(&self) -> bool

where E: Eq + Hash,

Returns whether the path is simple.

On our definition, a path is simple if it has no repeated edges.

pub fn reduce(self, fv: impl FnOnce(V) -> E, fe: impl FnMut(E, E) -> E) -> E

Reduces a path using functions on vertices and edges.

pub fn map<CodV, CodE>( self, fv: impl FnOnce(V) -> CodV, fe: impl FnMut(E) -> CodE, ) -> Path<CodV, CodE>

Maps a path over functions on vertices and edges.

pub fn map_reduce<T>( self, fv: impl FnOnce(V) -> T, fe: impl FnMut(E) -> T, f: impl FnMut(T, T) -> T, ) -> T

Maps and then reduces over a path.

This equivalent to calling map and then reduce but avoids allocating the intermediate path.

pub fn partial_map<CodV, CodE>( self, fv: impl FnOnce(V) -> Option<CodV>, fe: impl FnMut(E) -> Option<CodE>, ) -> Option<Path<CodV, CodE>>

Maps a path over partial functions on vertices and edges.

pub fn try_map<CodV, CodE, Err>( self, fv: impl FnOnce(V) -> Result<CodV, Err>, fe: impl FnMut(E) -> Result<CodE, Err>, ) -> Result<Path<CodV, CodE>, Err>

Maps a path over fallible functions on vertices and edges.

impl<V, E> Path<V, Path<V, E>>

pub fn flatten(self) -> Path<V, E>

Flattens a path of paths into a single path.

Unlike flatten_in, this method does not check that the composite is well typed before computing it.

pub fn flatten_in(self, graph: &impl Graph<V = V, E = E>) -> Option<Path<V, E>>

where V: Eq + Clone,

Flattens a path of paths in a graph into a single path.

Returns the flattened path just when the original paths have compatible start and end points.

Trait Implementations

impl<V: Clone, E: Clone> Clone for Path<V, E>

fn clone(&self) -> Path<V, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, E: Debug> Debug for Path<V, E>

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

Formats the value using the given formatter.

impl<V, E> From<E> for Path<V, E>

Converts an edge into a path of length one.

fn from(e: E) -> Self

Converts to this type from the input type.

impl From<Path<QualifiedName, QualifiedName>> for MorType

fn from(value: QualifiedPath) -> Self

Converts to this type from the input type.

impl<V, E> From<ShortPath<V, E>> for Path<V, E>

fn from(path: ShortPath<V, E>) -> Self

Converts to this type from the input type.

impl<V: Hash, E: Hash> Hash for Path<V, E>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<V, E> IntoIterator for Path<V, E>

Converts the path into an iterater over its edges.

type Item = E

The type of the elements being iterated over.

type IntoIter = Either<Empty<E>, <NonEmpty<E> as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V: PartialEq, E: PartialEq> PartialEq for Path<V, E>

fn eq(&self, other: &Path<V, E>) -> 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<V, E> TryFrom<Path<V, E>> for ShortPath<V, E>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(path: Path<V, E>) -> Result<Self, Self::Error>

Performs the conversion.

impl<V: Eq, E: Eq> Eq for Path<V, E>

impl<V, E> StructuralPartialEq for Path<V, E>