use std::marker::PhantomData;

pub trait Marker {}
impl Marker for () {}

pub trait Relation {
    type Domain: Marker;
    type Codomain: Marker;
}

pub trait Follow<R: Relation, E: Marker, const DIR: bool> {}

impl<R: Relation> Follow<R, R::Codomain, true> for R::Domain {}
impl<R: Relation> Follow<R, R::Domain, false> for R::Codomain {}

// this bound on T is somehow important?
pub trait Container<T: Marker>: IntoIterator<Item = T> {
    type WithReplacedMarker<N: Marker>: Container<N>;
    type IDContainer;
}

impl<T: Marker> Container<T> for Option<T> {
    type WithReplacedMarker<N: Marker> = Option<N>;
    type IDContainer = Option<()>;
}

struct StubQueryable<E: Marker, C: Container<E>>(PhantomData<(E, C)>);

impl<E: Marker, C: Container<E>> Queryable for StubQueryable<E, C> {
    type Output = E;
    type Container = C;
}

pub trait Queryable {
    type Output: Marker;
    type Container: Container<Self::Output>;

    fn finish(&self) -> <Self::Container as Container<Self::Output>>::IDContainer {
        todo!()
    }

    fn follow<R: Relation, E: Marker, const DIR: bool>(
        &self,
        _r: &R,
    ) -> impl Queryable<Output = E, Container = Option<E>> {
        StubQueryable::<E, Option<E>>(PhantomData)
    }
}


struct R;
impl Relation for R {
    type Domain = ();
    type Codomain = ();
}

fn run_on(q: &impl Queryable<Output = (), Container = Option<()>>) {
    // this line causes rustc to hang:
    q.follow(&R).finish();
}