Making C-SEALED trait private method, impossible to call.

[rbran]

I had a similar problem to the one described in "C-SEALED" , but the private methods needed to be impossible to be called.

I ended up with a solution equivalent to that:

/// This trait is sealed and cannot be implemented for types outside this crate.
pub trait TheTrait: private::Sealed {
    // public methods only
    fn test1();
}

// Implement TheTrait for all types that implement the Sealed Trait
impl<T: private::Sealed> TheTrait for T {
    fn test1() {
        //just forward the call to the private implementation
        <Self as private::Sealed>::test1()
    }
}

mod private {
    // Zero or more private methods, not allowed for user to call.
    pub trait Sealed {
        //public methods
        fn test1();
        //private methods
        fn test2();
    }

    // Implement for those types allowed
    impl Sealed for usize {
        fn test1() { todo!() }
        fn test2() { todo!() }
    }
}

If you don't mind separating the trait in two, you can simplify the code:

/// This trait is sealed and cannot be implemented for types outside this crate.
pub trait TheTrait: private::Sealed {
    // public methods only
    fn test1();
}

mod private {
    // Zero or more private methods, not allowed for user to call.
    pub trait Sealed {
        fn test2();
    }

    // Implement for those same types, but no others.
    impl Sealed for usize {
        fn test2() { todo!() }
    }
    impl crate::TheTrait for usize {
        fn test1() { todo!() }
    }
}

I personally think that enforcing the function to be private, generating an error at compile time if used, seems a more solid implementation, even if it require a little of boiler-plate.