Struct Relation 

pub struct Relation<C: Op_> { /* private fields */ }

Implementations

impl<C: Op> Relation<C>

pub fn minus( self, other: Relation<impl Op<D = C::D>>, ) -> Relation<impl Op<D = C::D>>

impl<C: Op_> Relation<C>

pub fn dynamic<'a>(self) -> Relation<Dynamic<'a, C::T>>

where C: 'a,

Simplifies the inferred type-signature of a relation at the cost of requiring dynamic dispatch at runtime.

Try inserting this in the middle of a big relation if the compiler is running slowly or using up too much memory.

impl<'a, K: Clone + Eq + Hash + 'a, V: Clone + Eq + Hash + 'a, C: Op<D = (K, V)> + 'a> Relation<C>

pub fn first_occurences<I>( self, context: &mut CreationContext<'a, I>, ) -> Relation<impl Op<D = (K, V)>>

impl<K: Clone + Eq + Hash, V: Clone + Eq + Hash, C: Op<D = (K, V)>> Relation<C>

pub fn semijoin( self, other: Relation<impl Op<D = K>>, ) -> Relation<impl Op<D = (K, V)>>

pub fn join_values<V2: Clone + Eq + Hash>( self, other: Relation<impl Op<D = (K, V2)>>, ) -> Relation<impl Op<D = (V, V2)>>

pub fn left_join<V2: Clone + Eq + Hash>( self, other: Relation<impl Op<D = (K, V2)>>, ) -> Relation<impl Op<D = (K, V, Option<V2>)>>

impl<C: Op> Relation<C>

where C::D: Clone + Eq + Hash,

pub fn intersection( self, other: Relation<impl Op<D = C::D>>, ) -> Relation<impl Op<D = C::D>>

pub fn set_minus( self, other: Relation<impl Op<D = C::D>>, ) -> Relation<impl Op<D = C::D>>

impl<C: Op_> Relation<C>

pub fn map_<Y, F: Fn(C::T) -> Y>(self, f: F) -> Relation<impl Op_<T = Y>>

pub fn debug(self, name: &'static str) -> Relation<impl Op_<T = C::T>>

where C::T: Debug,

impl<C: Op> Relation<C>

pub fn flat_map<I: IntoIterator>( self, f: impl Fn(C::D) -> I, ) -> Relation<impl Op<D = I::Item>>

pub fn flatten(self) -> Relation<impl Op<D = <C::D as IntoIterator>::Item>>

where C::D: IntoIterator,

pub fn map<Y>(self, f: impl Fn(C::D) -> Y) -> Relation<impl Op<D = Y>>

pub fn map_h<Y>(self, f: impl Fn(C::D) -> Y) -> Relation<impl Op<D = Y>>

pub fn filter(self, f: impl Fn(&C::D) -> bool) -> Relation<impl Op<D = C::D>>

pub fn map_counts( self, f: impl Fn(isize) -> isize, ) -> Relation<impl Op<D = C::D>>

pub fn negate(self) -> Relation<impl Op<D = C::D>>

impl<A, B, C: Op<D = (A, B)>> Relation<C>

pub fn fsts(self) -> Relation<impl Op<D = A>>

pub fn snds(self) -> Relation<impl Op<D = B>>

pub fn swaps(self) -> Relation<impl Op<D = (B, A)>>

impl<C: Op> Relation<C>

pub fn into_output(self, context: &CreationContext<'_>) -> Output<C::D, C>

where C::D: Eq + Hash,

impl<K, V, C: Op<D = (K, V)>> Relation<C>

pub fn into_kv_output( self, context: &CreationContext<'_>, ) -> Output<(K, V), C, HashMap<K, HashMap<V, isize>>>

where K: Eq + Hash, V: Eq + Hash,

pub fn into_extrema_output( self, context: &CreationContext<'_>, ) -> Output<(K, V), C, ExtremaMap<K, V>>

where K: Ord, V: Eq + Hash,

impl<C: Op> Relation<C>

where C::D: Clone + Eq + Hash,

pub fn counts( self, ) -> Relation<impl IsReduce<T = ((C::D, isize), isize), OM = HashMap<C::D, isize>>>

pub fn distinct(self) -> Relation<impl Op<D = C::D>>

impl<C: Op<D = (K, V)>, K: Clone + Eq + Hash, V> Relation<C>

pub fn reduce_<M: CountMap<V> + Observable, Y: Clone + Eq, F: Fn(&K, &M) -> Y>( self, f: F, ) -> Relation<Reduce<K, V, C, M, Y, HashMap<K, Y>, F>>

pub fn reduce<Y: Clone + Eq>( self, f: impl Fn(&K, &HashMap<V, isize>) -> Y, ) -> Relation<impl IsReduce<T = ((K, Y), isize), OM = HashMap<K, Y>>>

where V: Eq + Hash,

pub fn group_min( self, ) -> Relation<impl IsReduce<T = ((K, V), isize), OM = HashMap<K, V>>>

where V: Clone + Ord,

pub fn group_max( self, ) -> Relation<impl IsReduce<T = ((K, V), isize), OM = HashMap<K, V>>>

where V: Clone + Ord,

impl<C: Op<D = (L, R)>, L, R> Relation<C>

pub fn split(self) -> (Relation<impl Op<D = L>>, Relation<impl Op<D = R>>)

Splits a collection of 2-tuples into a 2-tuple of collections.

Example:

   use standing_relations::CreationContext;
   use std::{collections::HashMap, iter::FromIterator};

   let mut context = CreationContext::new();
   let (mut foo_input, foo) = context.new_input::<usize>();
   let (evens, odds) = foo.map(|x| (x * 2, x * 2 + 1)).split();
   let evens = evens.into_output(&context);
   let odds = odds.into_output(&context);
    
   let mut context = context.begin();
   foo_input.add_all(&context, 0 .. 2);
   context.commit();
   assert_eq!(&*evens.get(&context), &HashMap::from_iter(vec![(0,1),(2,1)]));
   assert_eq!(&*odds.get(&context), &HashMap::from_iter(vec![(1,1),(3,1)]));

impl<C: Op> Relation<C>

where C::D: Clone,

pub fn collect<'a>(self) -> Collection<'a, C::D>

where C: 'a,

pub fn t<D: Is<Myself = C::D>>(self) -> Self

No-op which nails down the expected item type.

The compiler will complain if the provided type is wrong. This helps you spot type errors where they occur rather than downstream.

Example:

   use standing_relations::CreationContext;
   use std::{collections::HashMap, iter::FromIterator};

   let mut context = CreationContext::new();
   let (_foo_input, foo) = context.new_input::<(char, isize)>();
   let (_bar_input, bar) = context.new_input::<char>();
   let foobar =
       foo.join(bar.counts()).flat_map(|(k,x,y)| if x < y {Some((k,x))} else {None});
   let foobar = foobar.t::<(char, isize)>();

Note that if instead of flat_map, we had accidentally used map, the compiler would complain because foobar would have item type Option<(char, isize)> where we expect (char, isize).

impl<C1: Op_> Relation<C1>

pub fn concat<C2: Op_<T = C1::T>>( self, other: Relation<C2>, ) -> Relation<Concat<C1, C2>>

impl<C: Op_<T = (D, isize)>, D: Eq + Hash> Relation<C>

pub fn consolidate(self) -> Relation<Consolidate<C>>

impl<C: Op_> Relation<C>

pub fn dynamic_shown<'a>(self) -> Relation<Dynamic<'a, C::T>>

where C: 'a,

impl<K: Clone + Eq + Hash, V1: Clone + Eq + Hash, C1: Op<D = (K, V1)>> Relation<C1>

pub fn join<V2: Clone + Eq + Hash, C2: Op<D = (K, V2)>>( self, other: Relation<C2>, ) -> Relation<Join<K, V1, V2, C1, C2>>

pub fn antijoin<C2: Op<D = K>>( self, other: Relation<C2>, ) -> Relation<AntiJoin<K, V1, C1, C2>>

Retains only those keys which have count 0 in the argument relation.

impl<C: Op_> Relation<C>

pub fn flat_map_<I: IntoIterator, F: Fn(C::T) -> I>( self, f: F, ) -> Relation<FlatMap<C, I, F>>

impl<C: Op<D = (K, X)>, K: Clone + Eq + Hash, X> Relation<C>

pub fn reduce_with_output_<M: CountMap<X> + Observable, OM: OutputMap<K, Y> + Default, Y: Clone + Eq, F: Fn(&K, &M) -> Y>( self, f: F, ) -> Relation<Reduce<K, X, C, M, Y, OM, F>>

impl<C: IsReduce> Relation<C>

pub fn probe(self, context: &CreationContext<'_>) -> ReduceProbe<C>

impl<C: Op_> Relation<C>

pub fn save(self) -> Saved<C>

where C::T: Clone,

impl<C: Op_<T = (L, R)>, L, R> Relation<C>

pub fn split_( self, ) -> (Relation<Split<L, C, L, R>>, Relation<Split<R, C, L, R>>)

impl<X: Clone + Eq + Hash, Y: Clone + Eq + Hash, C1: Op<D = (X, Y)>> Relation<C1>

pub fn triangles<Z: Clone + Eq + Hash, C2: Op<D = (X, Z)>, C3: Op<D = (Y, Z)>>( self, rel2: Relation<C2>, rel3: Relation<C3>, ) -> Relation<Triangles<X, Y, Z, C1, C2, C3>>

impl<C: Op> Relation<C>

pub fn into_output_<M: CountMap<C::D>>( self, context: &CreationContext<'_>, ) -> Output<C::D, C, M>

impl<C: Op_> Relation<C>

pub fn tracking_index(&self) -> TrackingIndex

pub fn named(self, name: &str) -> Self

pub fn type_named(self, type_name: &str) -> Self

pub fn hidden(self) -> Self

Trait Implementations

impl<C: Op_> Clone for Relation<Save<C>>

where C::T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.