Proposal: Trait Derivation

Short story: rust should enable a specific flavor of supertrait-subtrait relationship, that is, when a trait B is implemented, trait A would also be derived as a supertrait.

A bit longer story: sometimes, it is only reasonable for certain methods of a supertrait A to be related to that of a subtrait B in certain ways. For a plausible example,

pub mod Graph {
    pub trait Graph {
        type Node; 
        fn adj(&self, node: Self::Node) -> Vec<Box<Self::Node>>; 
    }
}

pub mod tree { 
    // import Graph 

    pub trait Tree { 
        fn parent(&self) -> Option<Box<Self>>; 
        fn children(&self) -> Vec<Box<Self>>;
    } 

    // Now, it would be somewhat natural to do the following: 
    // imaginary syntax 
    derive Graph for Tree { 
        type Node = Self; 
        fn adj(&self, node: Self::Node) -> Vec<Box<Self::Node>> { 
            let mut result: Vec<Box<Self::Node>> = node.children(); 
            match node.parent() {
                Some(p) -> { result.push(p); }
                None -> {}
            }
            result
        } 
    } 
} 

Note that a blanket implementation is not what I'm suggesting, as it has necessary restrictions imposed by the orphan rule.

The reason for this, in a narrower sense, is that it is often perfectly natural to want to automatically derive some traits from one without manual implementation for each concrete type; and perhaps in a general and broader sense, is to extend the variety of the relationships between traits that is so far limited to plain supertrait-subtrait by injecting some dependence of the supertrait on the subtrait, while usually the dependence is that of the subtrait on the supertrait.

And btw I am a newbie in rust and a very inexperienced programmer, and I am open to any suggestions or corrections.

No repository files, tests, or implementation entry points are identified. Start by reviewing the proposed trait-derivation examples and the Rust RFC process, then determine the language-design and implementation scope. Done would require an agreed design and an accepted path for the proposed relationship.