Idea: Private trait

[rbran]

At some point it was useful to me to have an "trait with private functions", rust don't implement that, but I had the idea of using a "private trait" and expose only a few methods of this trait using a "public trait".

Here an example of a Car trait that only exposes three functions, but internally uses other two. The pattern can be describe like that.

The lib.rs file:

//trait that is exposed to all classes
pub trait Car {
    fn get_speed(&self) -> f64;
    fn accelerate(&mut self, duration: f64);
    fn brake(&mut self, force: f64);
}
//not public
mod inner_lib {
    //trait that is exposed only to inner classes
    pub(crate) trait InnerCar {
        fn get_speed(&self) -> f64;
        //private
        fn set_speed(&mut self, new_speed: f64);
        //private
        fn get_acceleration(&self) -> f64;
        fn accelerate(&mut self, duration: f64) {
            self.set_speed(self.get_speed() + (self.get_acceleration() * duration));
        }
        fn brake(&mut self, force: f64) {
            self.set_speed(self.get_speed() - (force * self.get_acceleration()));
        }
    }
    //Auto implement Car for all InnerCar, by forwarding the Car trait to the InnerCar implementation
    impl<T: InnerCar> crate::Car for T {
        fn get_speed(&self) -> f64 {<Self as InnerCar>::get_speed(self)}
        fn accelerate(&mut self, duration: f64) {<Self as InnerCar>::accelerate(self, duration)}
        fn brake(&mut self, force: f64) {<Self as InnerCar>::brake(self, force)}
    }
}

#[derive(Default)]
pub struct Car1(f64);
//is not necessary to implement `accelerate` and `brake`, as inner_trait can do that.
impl inner_lib::InnerCar for Car1 {
    fn get_speed(&self) -> f64 {self.0}
    fn set_speed(&mut self, new_speed: f64) {self.0 = new_speed}
    fn get_acceleration(&self) -> f64 {0.10}
}
//more Car implementations...

//The bin using the lib:

use carlib::{Car1, Car};
fn main() {
    let mut car = Car1::default();
    car.accelerate(10.0);
    car.brake(10.0);
    //car.set_speed(100.0); //can't use, is private
    println!("car speed: {}", car.get_speed());
}

The main point of this example is that the public trait can't implement the break and accelerate functions by itself, to be able to do so would require the trait to expose the functions set_speed and get_acceleration, what we don't want to be exposed.

We could implement break and accelerate directly on Car1 removing the need to a InnerTrait, but doing so would required code duplication if we have multiple Car implementations.

[burdges]

You'd often have Car: InnerCar making a sealed trait, but with actual methods on the sealing trait.

[rbran]

A sealed trait and a private trait are usually used together, but they can be presented as separated concepts.

If you want a sealed trait:

trait Sealed;
pub trait Car: Sealed{...}

If you want a private trait:

pub trait Car{...}
trait InnerCar{...}
impl<T: InnerCar> Car for T {...}

If you want both:

trait Sealed;
pub trait Car: Sealed {...}
trait InnerCar{...}
impl<T: InnerCar> Car for T {...}

I think is better to present then separated, although similar, they do different things.

[rbran]

I created two separated PRs to demonstrate the concepts Sealed and InnerTrait