Struct Leaf

pub struct Leaf<T> {
    pub before: T,
    pub after: T,
}

A primitive or atomic change.

T is normally a reference of some kind, but it can be any type.

For more information, see the crate-level documentation.

Fields

before: T

The value on the before side.

after: T

The value on the after side.

Implementations

impl<T> Leaf<T>

pub fn as_ref(&self) -> Leaf<&T>

Convert from &Leaf<T> to Leaf<&T>.

pub fn as_mut(&mut self) -> Leaf<&mut T>

Convert from &mut Leaf<T> to Leaf<&mut T>.

pub fn as_deref(&self) -> Leaf<&T::Target>

where T: Deref,

Convert from Leaf<T> or &Leaf<T> to Leaf<&T::Target>.

Example

use daft::Leaf;

let x: Leaf<String> = Leaf { before: "hello".to_owned(), after: "world".to_owned() };
assert_eq!(x.as_deref(), Leaf { before: "hello", after: "world" });

pub fn as_deref_mut(&mut self) -> Leaf<&mut T::Target>

where T: DerefMut,

Convert from Leaf<T> or &mut Leaf<T> to Leaf<&mut T::Target>.

Example

use daft::Leaf;

let mut x: Leaf<String> = Leaf { before: "hello".to_owned(), after: "world".to_owned() };
assert_eq!(
    x.as_deref_mut().map(|x| {
        x.make_ascii_uppercase();
        x
    }),
    Leaf { before: "HELLO".to_owned().as_mut_str(), after: "WORLD".to_owned().as_mut_str() },
);

pub fn map<U, F>(self, f: F) -> Leaf<U>

where F: FnMut(T) -> U,

Map a Leaf<T> to a Leaf<U> by applying a function to the before and after values.

f will be called twice: first with before, then with after.

Example

A Leaf<&str> can be converted to a Leaf<String> by calling map with String::from:

use daft::{Diffable, Leaf};

let before = "hello";
let after = "world";

let leaf: Leaf<&str> = Leaf { before, after };
let leaf: Leaf<String> = leaf.map(String::from);

pub fn is_unchanged(&self) -> bool

where T: Eq,

Return true if before is the same as after.

This is the same as self.before == self.after, but is easier to use in a chained series of method calls.

Example

use daft::{Diffable, Leaf};

let before = "hello";
let after = "hello";

let leaf: Leaf<&str> = Leaf { before, after };
assert!(leaf.is_unchanged());

let before = "hello";
let after = "world";

let leaf: Leaf<&str> = Leaf { before, after };
assert!(!leaf.is_unchanged());

pub fn is_modified(&self) -> bool

where T: Eq,

Return true if before is different from after.

This is the same as self.before != self.after, but is easier to use in a chained series of method calls.

Example

use daft::{Diffable, Leaf};

let before = "hello";
let after = "hello";

let leaf: Leaf<&str> = Leaf { before, after };
assert!(!leaf.is_modified());

let before = "hello";
let after = "world";

let leaf: Leaf<&str> = Leaf { before, after };
assert!(leaf.is_modified());

impl<'daft, T: ?Sized + Diffable> Leaf<&'daft T>

pub fn diff_pair(self) -> T::Diff<'daft>

Perform a diff on before and after, returning T::Diff.

This is useful when T::Diff is not a leaf node.

impl<T> Leaf<&T>

pub fn cloned(self) -> Leaf<T>

where T: Clone,

Create a clone of the leaf with owned values.

Example

use daft::{Diffable, Leaf};

let before = String::from("hello");
let after = String::from("world");

let leaf: Leaf<&String> = Leaf { before: &before, after: &after };
// cloned turns a Leaf<&String> into a Leaf<String>.
let leaf: Leaf<String> = leaf.cloned();
assert_eq!(leaf.before, "hello");
assert_eq!(leaf.after, "world");

pub fn copied(self) -> Leaf<T>

where T: Copy,

Create a copy of the leaf with owned values.

Example

use daft::{Diffable, Leaf};

let before = "hello";
let after = "world";

let leaf: Leaf<&&str> = Leaf { before: &before, after: &after };
// copied turns a Leaf<&&str> into a Leaf<&str>.
let leaf: Leaf<&str> = leaf.copied();
assert_eq!(leaf.before, "hello");
assert_eq!(leaf.after, "world");

Trait Implementations

impl<T: Clone> Clone for Leaf<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Leaf<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Leaf<T>

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

Tests for self and other values to be equal, and is used by ==.

const 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: Copy> Copy for Leaf<T>

impl<T: Eq> Eq for Leaf<T>

impl<T> StructuralPartialEq for Leaf<T>