Componente genérico da caixa de especificações de ferrugem no sistema

Estou tentando implementar um sistema para usar um componente genérico, mas continuo tendo problemas com o método join quando tento alterar a variável. Aqui está uma versão simplificada do código que tenho:

use specs::{Component, prelude::*};


#[derive(Component, Debug, Default)]
#[storage(NullStorage)]
pub struct FooMarker;



#[derive(Component, Debug, Default)]
#[storage(VecStorage)]
pub struct Foo(pub f64);



pub trait Variable: Component + std::fmt::Debug + Default + Send + Sync + 'static {
    fn get_value(&self) -> f64;
    fn set_value(&mut self, value: f64);
}


impl Variable for Foo {
    fn get_value(&self) -> f64 {
        self.0
    }
    fn set_value(&mut self, value: f64) {
        self.0 = value;
    }
}


#[derive(Default)]
pub struct ChangeVariableSystem<T: Default=Foo> {
    _phantom_variable: std::marker::PhantomData<T>,
}


impl <'a, T> System<'a> for ChangeVariableSystem<T> 
where
    T: Component + Variable + Default + Send + Sync + 'static,
{
    type SystemData = (
        ReadStorage<'a, FooMarker>,
        WriteStorage<'a, T>,
    );

    fn run(&mut self, data: Self::SystemData) {
        let (
            markers,
            mut variables,
        ) = data;

        (&variables, &markers).join()
            .for_each(|(variable, _)| {
                variable.get_value();
                println!("{:?}", variable);
            });

        (&mut variables, &markers).join()
            .for_each(|(variable, _)| {
                variable.set_value(1.0);
                println!("{:?}", variable);
            });
    }
}


fn main() {
    let mut world = World::new();
    
    
    world.register::<Foo>();
    world.register::<FooMarker>();
    
    for _ in 0..10 {
        world.create_entity()
            .with(Foo(0.0))
            .with(FooMarker)
            .build();
    }
    
    let mut dispatcher = DispatcherBuilder::new()
        .with(
            ChangeVariableSystem::<Foo>::default(), 
            "change_variable_system", 
            &[],
        ).build();    
}

No código anterior, não tive problemas na primeira junção porque a variável não sofreu mutação, mas no segundo, tive o seguinte problema:

error[E0599]: the method `join` exists for tuple `(&mut Storage<'_, T, FetchMut<'_, MaskedStorage<T>>>, &Storage<'_, FooMarker, Fetch<'_, 
MaskedStorage<FooMarker>>>)`, but its trait bounds were not satisfied
  --> project\examples\generics.rs:60:36
   |
60 |         (&mut variables, &markers).join()
   |                                    ^^^^ method cannot be called due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `&mut Storage<'_, T, FetchMut<'_, MaskedStorage<T>>>: specs::Join`
           which is required by `(&mut Storage<'_, T, FetchMut<'_, MaskedStorage<T>>>, &Storage<'_, FooMarker, Fetch<'_, MaskedStorage<FooMarker>>>): specs::Join`
           `<T as specs::Component>::Storage: SharedGetMutStorage<T>`
           which is required by `(&mut Storage<'_, T, FetchMut<'_, MaskedStorage<T>>>, &Storage<'_, FooMarker, Fetch<'_, MaskedStorage<FooMarker>>>): specs::Join`

For more information about this error, try `rustc --explain E0599`.

Não consigo descobrir como resolver isso. A ligação da característica do componente não deveria ser suficiente para resolver o problema? Pode me ajudar?

Eu tentei a mesma coisa usando as especificações da versão 0.19 e funcionou. Isso é um bug da versão 0.20?

Obrigado!