Struct Pairs 

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

Two states of a collection, matched item by item, ready to be sampled at any t.

Built once per change, sampled once per frame: matching is the part that costs something and it does not depend on t. Pairs::by_key matches by an identity the caller derives; a caller whose own rules already know what moved where (a sliding-tile game knows which tiles merged) collects its Pairs directly (Pairs: FromIterator).

use day_core::tween::{Change, Lerp, Pairs, lerp};

#[derive(Clone, Debug, PartialEq)]
struct Bar { name: &'static str, height: f64 }

impl Lerp for Bar {
    fn lerp(&self, to: &Self, t: f64) -> Self {
        Bar { name: to.name, height: lerp(self.height, to.height, t) }
    }
}

let bar = |name, height| Bar { name, height };
// "b" shrinks, "c" grows out of nothing, "a" collapses away.
let before = [bar("a", 3.0), bar("b", 5.0)];
let after = [bar("b", 1.0), bar("c", 4.0)];
let pairs = Pairs::by_key(&before, &after, |b| b.name, |b, _| bar(b.name, 0.0));
assert_eq!(pairs.at(0.5), vec![bar("b", 3.0), bar("c", 2.0), bar("a", 1.5)]);
assert_eq!(pairs[2].change, Change::Leaving);

Implementations

impl<T: Clone> Pairs<T>

pub fn by_key<K: Eq + Hash>( from: &[T], to: &[T], key: impl FnMut(&T) -> K, absent: impl FnMut(&T, Change) -> T, ) -> Self

Match from with to by key.

• An item whose key is on both sides is Change::Kept. Keys may repeat: the nth item with a key on one side matches the nth with that key on the other, so identical tokens (three red gems in a column) pair up in order rather than all with the first.
• An item only in to is Change::Entering; absent(item, Change::Entering) says where it starts. An item only in from is Change::Leaving; absent(item, Change::Leaving) says where it ends. That stand-in is the whole of what entering and leaving mean: grown from a baseline, faded out, slid in from a neighbor. The caller decides; the match does not.

The result is in to’s order, then the leaving items in from’s order, so a renderer drawing in sequence draws the arriving picture’s order, with what is departing on top.

impl<T> Pairs<T>

pub fn at_with<U>(&self, t: f64, f: impl FnMut(&Pair<T>, f64) -> U) -> Vec<U>

Every item t of the way along, in order, through f: for items whose in-between depends on more than the two ends (a chart mark needs both charts’ scales to place itself).

pub fn at_each<U>( &self, progress: impl FnMut(usize, &Pair<T>) -> f64, f: impl FnMut(&Pair<T>, f64) -> U, ) -> Vec<U>

Each item at its own progress: progress(index, pair) gives the t for that item, for sequences that do not move in lockstep (cards dealt one after another, see stagger).

pub fn settled(&self) -> impl Iterator<Item = &T>

The arriving state: every item that is not leaving, at its end. What to draw once the transition is over.

pub fn counts(&self) -> (usize, usize, usize)

How many items of each kind of Change there are: (kept, entering, leaving).

pub fn iter(&self) -> Iter<'_, Pair<T>>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

impl<T: Lerp> Pairs<T>

pub fn at(&self, t: f64) -> Vec<T>

Every item t of the way along, in order. Leaving items are included until the caller stops sampling: at t = 1 they sit at their stand-ins.

Trait Implementations

impl<T: Clone> Clone for Pairs<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Pairs<T>

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

Formats the value using the given formatter.

impl<T> Default for Pairs<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> FromIterator<Pair<T>> for Pairs<T>

fn from_iter<I: IntoIterator<Item = Pair<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> Index<usize> for Pairs<T>

type Output = Pair<T>

The returned type after indexing.

fn index(&self, i: usize) -> &Pair<T>

Performs the indexing (container[index]) operation.

impl<T> IntoIterator for Pairs<T>

type Item = Pair<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<Pair<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Pairs<T>

type Item = &'a Pair<T>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Pair<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for Pairs<T>

fn eq(&self, other: &Pairs<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for Pairs<T>