use std::ops::{Deref, DerefMut};

// POOL

trait Pool {
    type Item: ?Sized;
    type Wrapper: DerefMut<Target=Self::Item>;

    fn get(&self) -> Self::Wrapper;
}

// DEREF POOL

struct DerefPool<Inner>(Inner);
struct DerefWrapper<Wrapper>(Wrapper);

impl <Wrapper> Deref for DerefWrapper<Wrapper> where
    Wrapper: Deref,
    Wrapper::Target: Deref,
{
    type Target = <<Wrapper as Deref>::Target as Deref>::Target;

    fn deref(&self) -> &Self::Target {
        &**self.0
    }
}

impl <Wrapper> DerefMut for DerefWrapper<Wrapper> where
    Wrapper: DerefMut,
    Wrapper::Target: DerefMut,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut **self.0
    }
}

impl <Inner> Pool for DerefPool<Inner> where
    Inner: Pool,
    Inner::Item: DerefMut,
{
    type Item = <<Inner as Pool>::Item as Deref>::Target;
    type Wrapper = DerefWrapper<Inner::Wrapper>;

    fn get(&self) -> Self::Wrapper {
        DerefWrapper(self.0.get())
    }
}


fn main() {

}