Struct Dual 

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

A dual-ownership (non-sync) reference cell

• uses a Cell<bool> internally
• implements Send if T implements Send

you can access the value using the Deref impl

use duals::Dual;

// create a new `Dual`
let (left, right) = Dual::new(10);

println!("{:?} {:?}", *left, *right);
drop(left);
println!("{:?}", *right);
drop(right);

Implementations

impl<T> Dual<T>

pub fn new(value: T) -> (Self, Self)

create a new Dual

use duals::Dual;
let (left, right) = Dual::new(10);

pub fn other_exists(&self) -> bool

check if the other Dual reference exists

use duals::Dual;
let (left, right) = Dual::new(10);

assert!(left.other_exists()); // true;
drop(right);
assert!(!left.other_exists()); // false;

pub fn take(&self) -> T

where T: Clone,

clone the value from inside the reference

Trait Implementations

impl<T> Debug for Dual<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Dual<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Drop for Dual<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for Dual<T>

where T: Send,