How do I disambiguate different/mutual type associations that point to the same type? - rust

Question

I have a series of traits that are mutually associated, and contain further type associations that are meant to be enums. I've left the Id type associations repeated in each trait that needs it, to avoid deeply nested fully-qualified names like <<World as World>::Exit as Exit>::SpotId but this is leading to confusion now that I'm implementing behavior relying on these "top-level" traits:
trait Accessible {
type Context: Ctx;
fn can_access(&self, ctx: &Self::Context) -> bool;
}
trait Id: Copy + Clone + Debug + Eq + Hash + Ord + PartialOrd {}
trait Location: Accessible {
type LocId: Id;
type ExitId: Id;
}
trait Exit: Accessible {
type ExitId: Id;
type SpotId: Id;
type LocId: Id;
}
trait World {
type Context: Ctx;
type Location: Location;
type Exit: Exit;
type SpotId: Id;
fn get_neighbors(&self, spot_id: Self::SpotId) -> &[Self::SpotId];
}
trait Ctx: Clone + Eq {
type World: World<Context = Self, SpotId = Self::SpotId>;
type SpotId: Id;
}
fn expand<T>(world: &impl World<Context = T>, ctx: &T, start: <T as Ctx>::SpotId)
where T: Ctx,
{
for spot in world.get_neighbors(start) { }
}
(on the rust playground)
This produces an error on world.get_neighbors:
| expected `World::SpotId`, found `Ctx::SpotId`
= note: expected associated type `<impl World<Context = T> as World>::SpotId`
found associated type `<T as context::Ctx>::SpotId`
and vice versa on some other uses of a SpotId.
Is there a clean way to maintain the mutual associations and have a simple typename for (e.g.) SpotId so that it doesn't matter which trait's version of SpotId is named?
I've tried to add more annotations to make clear that they must be inferred to be the same type:
trait World {
type Context: Ctx<SpotId = Self::SpotId, World = Self>;
type Location: Location + Accessible<Context = Self::Context>;
type Exit: Exit<SpotId = Self::SpotId> + Accessible<Context = Self::Context>;
type SpotId: Id;
}
but get the same error.
I've looked at https://users.rust-lang.org/t/type-alias-for-readability-with-associated-traits/64044/2 which recommends using type aliases to manage fully-qualified names, but I've been unsure how to get started with that.
Update: it's possible to specify that one type fulfills both requirements via a type parameter:
fn expand<T, S>(world: &impl World<Context = T, SpotId = S>, ctx: &T, start: S)
where T: Ctx<SpotId = S>, S: Id,
{
for spot in world.get_neighbors(start) { }
}
but as development continues, my functions start looking more like
fn explore<T, S, L, E>(
world: &impl World<
Context = T,
SpotId = S,
Exit = impl Exit<ExitId = E, SpotId = S> + Accessible<Context = T>,
Location = impl Location<LocId = L> + Accessible<Context = T>,
>,
ctx: &T,
)
where
T: Ctx<SpotId = S, LocationId = L, ExitId = E> + Debug,
S: Id,
L: Id,
E: Id,
{ ... }
and every caller has to be modified whenever I add a use of another id type (there are a few more I omitted here for brevity). I should probably seek a solution at the trait level.

Answer 1

All you have to do is require that these associated types are the same type in the definition of fn expand, which you can do by introducing another generic parameter:
fn expand<T: Ctx<SpotId = S>, S>(
world: &impl World<Context = T, SpotId = S>,
ctx: &T,
start: S
) {
for spot in world.get_neighbors(start) { }
}
Adding the parameter S and constraining both Ctx and World to have SpotId = S tells the compiler that they must be the same type in order to allow this function to be invoked.
(Playground)

Answer 2

Here's what ended up working. Ignoring the circular dependency in Accessible, I reorganized types so that World only has one path to each Id type, and then used fully-qualified syntax in the trait functions. Then, I changed the generic types in the functions to use the types that implement the place traits rather than the Ids, since it's easier to write the trait bounds, including some odd cases like this struct I added that really only needs Ctx and SpotId but has to provide the bound that they're related.
trait World {
type Location: Location;
type Exit: Exit<
ExitId = <Self::Location as Location>::ExitId,
LocId = <Self::Location as Location>::LocId,
Context = <Self::Location as Accessible>::Context,
>;
fn get_neighbors(&self, spot_id: <Self::Exit as Exit>::SpotId) -> &[<Self::Exit as Exit>::SpotId];
}
trait Ctx {
type World: World;
}
struct SpotAccess<T, S>
where
T: Ctx,
S: Id,
<T::World as World>::Exit: Exit<SpotId = S>,
{ ... }
fn expand<W, T, E>(world: &W, ctx: &T, start: SpotAccess<T, E::SpotId>)
where
W: World<Exit = E>,
T: Ctx<World = W>,
E: Exit<Context = T>,
{ ... }
I'm not sure if the bound on World::Exit that its associated types are the same as World::Location's but is required but I'll leave it for now.