// Uses Hash impl A
fn insert<T: Hash>(...)

// Uses Hash impl B
fn get<T: Hash>(...)

// In the nom crate
impl Iterator for &[u8] { ... }

// In the serde crate
impl Iterator for &[u8] { ... }

pub struct Foo;

// Only I can add this impl
// because Foo is MY type
impl Display for Foo { ... }

// In crate A:
trait Foo { ... }
impl<T> Foo for T { ... }

// In crate B:
struct Bar { ... }
// This impl is more specialized
impl Foo for Bar { ... }

// If crate C uses both A and B,
// a single, correct impl should
// always be used consistently

MyTrait::foo() // <-- Maps to ONE implementation

impl<T> MyTrait for T { ... } // <-- Can only be written in ONE place

loves(sunjay, cake)
loves(T, candy) :- loves(T, cake)

?- loves(sunjay, candy)
Yes

// Each type T implements MyTrait
forall<T> { Implemented(T: MyTrait) }

// There is at least one type T
// that implements MyTrait
exists<T> { Implemented(T: MyTrait) }

// In crate "people":
extern crate favorites;

// In crate "favorites":
pub struct Taco { }
pub trait FavoriteColor {
    fn fav() -> &'static str;
}
impl<T: Copy> FavoriteColor for T {
    fn fav() -> &'static str { "purple" }
}

// In crate "std":
pub trait Copy { }

use favorites::*;

struct Sunjay;
impl FavoriteColor for Sunjay {
    fn fav() -> &'static str { "red" }
}

struct Manish;
impl FavoriteColor for Manish {
    fn fav() -> &'static str { "orange" }
}

IsLocal(Sunjay)
IsLocal(Manish)

Implemented(Sunjay: FavoriteColor)
Implemented(Manish: FavoriteColor)

IsUpstream(Taco)

forall<T> { Implemented(T: FavoriteColor)
                :- Implemented(T: Copy) }

// In crate "foo"
pub trait MyTrait<T, U> { }
pub struct Foo { }

// In crate "bar"
extern crate foo;
use foo::*;

struct Bar { }
impl<T> MyTrait<Bar, T> for Foo { }

// Type parameters in order: Foo, Bar, T

struct Turtle;

// Is LocalImplAllowed(Turtle: Display) provable?
// Yes. Turtle is a local type
impl Display for Turtle { ... }

// Is LocalImplAllowed(Vec<Turtle>: Display) provable?
// No. Vec<T> is defined in std and the orphan rules
// say that only std can add impls for it
impl Display for Vec<Turtle> { ... }

forall<Self, T, U> { LocalImplAllowed(Self: MyTrait<T, U>) }

forall<Self, T, U> {
    LocalImplAllowed(Self: MyTrait<T, U>) :-
        IsLocal(Self)
}
forall<Self, T, U> {
    LocalImplAllowed(Self: MyTrait<T, U>) :-
        IsFullyVisible(Self),
        IsLocal(T)
}
forall<Self, T, U> {
    LocalImplAllowed(Self: MyTrait<T, U>) :-
        IsFullyVisible(Self),
        IsFullyVisible(T),
        IsLocal(U)
}

trait MyTrait<T, U> { }

// In crate "foo":
pub struct Foo { }

// In crate "bar":
extern crate foo;

struct Bar { }

pub struct Spam<T, U> { ... }

IsFullyVisible(Foo)

IsFullyVisible(Bar)

// Notice that there isn't
// any IsFullyVisible(T)

forall<T, U> {
    IsFullyVisible(Spam<T, U>) :-
        IsFullyVisible(T),
        IsFullyVisible(U)
}

// In crate "foo": (current)
pub struct Foo<T> { ... }

// In crate "bar":
extern crate foo;

struct Bar<T> { ... }

forall<T> { IsLocal(Foo<T>) }