pub fn favor_over(self, other: Solution) -> Solution {
        use self::Guidance::*;

        if self == other { return self }

        // Otherwise, always downgrade to Ambig:

        let guidance = match (self.into_guidance(), other.into_guidance()) {
            (Definite(subst), _) | (Suggested(subst), _) => Suggested(subst),
            _ => Unknown,
        };
        Solution::Ambig(guidance)
    }
/// There are multiple candidate solutions, which may or may not agree on
/// the values for existential variables; attempt to combine them, while
/// favoring `self` for the purposes of giving suggestions to type
/// inference. This is used in particular to favor the `where` clause
/// environment over `impl`s in guiding inference in ambiguous situations.
///
/// It should always be the case that `x.favor_over(y)` is at least as
/// informative as `x.combine(y)`, in terms of guidance to type inference.
There are multiple candidate solutions, which may or may not agree on
the values for existential variables; attempt to combine them, while
favoring `self` for the purposes of giving suggestions to type
inference. This is used in particular to favor the `where` clause
environment over `impl`s in guiding inference in ambiguous situations.

It should always be the case that `x.favor_over(y)` is at least as
informative as `x.combine(y)`, in terms of guidance to type inference.
There are multiple candidate solutions which may or may not agree on the values for existential variables ; attempt to combine them while favoring ` self ` for the purposes of giving suggestions to type inference . This is used in particular to favor the ` where ` clause environment over ` impl ` s in guiding inference in ambiguous situations . It should always be the case that ` x . favor_over ( y ) ` is at least as informative as ` x . combine ( y ) ` in terms of guidance to type inference .
pub fn favor_over(self, other: Solution) -> Solution {
        use self::Guidance::*;
        if self == other { return self }
        // Otherwise, always downgrade to Ambig:
        let guidance = match (self.into_guidance(), other.into_guidance()) {
            (Definite(subst), _) | (Suggested(subst), _) => Suggested(subst),
            _ => Unknown,
        };
        Solution::Ambig(guidance)
    }
pub fn favor_over ( self , other : Solution ) -> Solution { use self :: Guidance :: * ; if self == other { return self } // Otherwise, always downgrade to Ambig: let guidance = match ( self . into_guidance ( ) , other . into_guidance ( ) ) { ( Definite ( subst ) , _ ) | ( Suggested ( subst ) , _ ) => Suggested ( subst ) , _ => Unknown , } ; Solution :: Ambig ( guidance ) }
There are multiple candidate solutions, which may or may not agree on
the values for existential variables; attempt to combine them, while
favoring `self` for the purposes of giving suggestions to type
inference.
There are multiple candidate solutions which may or may not agree on the values for existential variables ; attempt to combine them while favoring ` self ` for the purposes of giving suggestions to type inference .
self
other
Solution