Struct Converging 

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

The answer of a search: settled by a certificate, or provisional with its evidence.

Implementations

impl<T> Converging<T>

pub fn provisional(value: T, steps: u64, revisions: u64) -> Converging<T>

The current guess after steps cases, having changed revisions times, with no proof.

pub fn settled(value: T, certificate: &str) -> Converging<T>

A value a certificate settles.

pub fn value(&self) -> &T

pub fn with_value<U>(&self, value: U) -> Converging<U>

The same evidence for value.

pub fn steps(&self) -> u64

pub fn revisions(&self) -> u64

pub fn is_settled(&self) -> bool

pub fn certificate(&self) -> Option<&str>

pub fn joined<U, W>(&self, other: &Converging<U>, value: W) -> Converging<W>

The evidence of value, made from this answer and other: settled when both are (their certificates joined), the other’s evidence when one is settled, and otherwise provisional on the fewest cases either search checked with every revision either made.

pub fn render(&self, show: impl Fn(&T) -> String) -> String

A settled value prints as itself; a provisional one carries its evidence: false (provisional: checked 10,000,000 cases, 0 revisions; not proved).

Trait Implementations

impl<T: Clone> Clone for Converging<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Converging<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Converging<T>

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<T: PartialEq> PartialEq for Converging<T>

fn eq(&self, other: &Converging<T>) -> 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<T: Eq> Eq for Converging<T>

impl<T> StructuralPartialEq for Converging<T>