Trait UnifyValue

pub trait UnifyValue: Clone + Debug {
    type Error;

    // Required method
    fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error>;
}

Trait implemented for values associated with a unification key. This trait defines how to merge the values from two keys that are unioned together. This merging can be fallible. If you attempt to union two keys whose values cannot be merged, then the error is propagated up and the two keys are not unioned.

This crate provides implementations of UnifyValue for () (which is infallible) and Option<T> (where T: UnifyValue). The option implementation merges two sum-values using the UnifyValue implementation of T.

See also EqUnifyValue, which is a convenience trait for cases where the “merge” operation succeeds only if the two values are equal.

Required Associated Types

type Error

Defines the type to return when merging of two values fails. If merging is infallible, use the special struct NoError found in this crate, which unlocks various more convenient methods on the unification table.

Required Methods

fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error>

Given two values, produce a new value that combines them. If that is not possible, produce an error.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl UnifyValue for ()

type Error = NoError

fn unify_values(_: &(), _: &()) -> Result<(), NoError>

impl<V> UnifyValue for Option<V>

where V: UnifyValue,

type Error = <V as UnifyValue>::Error

fn unify_values( a: &Option<V>, b: &Option<V>, ) -> Result<Option<V>, <V as UnifyValue>::Error>

Implementors

impl<T> UnifyValue for T

where T: EqUnifyValue,

type Error = (T, T)