#![feature(never_type)]
#![feature(specialization)]

use core::ops::Range;

//
// Public
//

// Utilities
pub trait FamilyLt<'r> {
    type Out;
}

pub struct IdFamily<T>(std::marker::PhantomData<T>, !);
impl<'a, T> FamilyLt<'a> for IdFamily<T> {
    type Out = T;
}

pub struct SlicesFamily<T>(std::marker::PhantomData<T>, !);
impl<'a, T00: 'static> FamilyLt<'a> for SlicesFamily<(T00, )> {
    type Out = (&'a [T00], );
}
impl<'a, T00: 'static, T01: 'static> FamilyLt<'a> for SlicesFamily<(T00, T01)> {
    type Out = (&'a [T00], &'a [T01]);
}

pub type SlicesOf<'a, T> = <<T as Tuple>::Slices as FamilyLt<'a>>::Out;
pub trait Tuple {
    type Slices: for<'r> FamilyLt<'r>;
}

// Tuple impls
impl Tuple for () {
    type Slices = IdFamily<()>;
}

impl<T00: 'static> Tuple for (T00, ) {
    type Slices = SlicesFamily<(T00, )>;
}

impl<T00: 'static, T01: 'static> Tuple for (T00, T01) {
    type Slices = SlicesFamily<(T00, T01)>;
}

// Slices
pub struct Slices<'a, T: Tuple> {
    inner: Inner<'a, T>
}

impl<'a, T: Tuple> Slices<'a, T> {
    pub fn new(slices: SlicesOf<'a, T>) -> Self {
        Self {
            inner: Inner {
                slices
            }
        }
    }
}

//
// Internal
//

struct Inner<'a, T: Tuple> {
    slices: SlicesOf<'a, T>
}

trait InnerSpecialized {
    fn index(&self, range: Range<usize>) -> Self;
    fn drop(&mut self);
}

impl<'a, T: Tuple> InnerSpecialized for Inner<'a, T> {
    default fn index(&self, range: Range<usize>) -> Self { panic!("Not implemented for this type.") }
    default fn drop(&mut self) { panic!("Not implemented for this type.") }
}

impl<'a, T: Tuple> Drop for Inner<'a, T> {
    fn drop(&mut self) {
        <Self as InnerSpecialized>::drop(self);
    }
}

//
// Specializations
//

impl<'a, T00: 'static> InnerSpecialized for Inner<'a, (T00, )> {
    fn index(&self, range: Range<usize>) -> Self {
        Self {
            slices: (&self.slices.0[range], )
        }
    }
    fn drop(&mut self) {
    }
}

//
// Usage
//

fn main() {
    let v0: &[usize]  = &[1, 2, 3, 4];
    let v1: &[bool] = &[true, false, true, true];

    let slices: Slices<(usize, )> = Slices::new((v0, ));
    drop(slices); // Works (specialization is available)

    let slices: Slices<(usize, bool)> = Slices::new((v0, v1));
    drop(slices); // Fails (default impl)

    println!("Hello, world!");
}