I hope it's okay to ask here some noob questions. I was thinking that giving a timer into a driver might be a bad idea, because it probably binds it forever and can't be used outside. So I thought I try out whether it's true or not. And created a quite useless struct that has one field that implements the embedded_hal DelayUs trait. The struct has a function that im principle just calls the delay_us function of the inner field.
To test how this works I created a Delay type from the stm32f1 hal crate and put it in. I then wanted to call delay on the new struct and the timer etc. I know already that this want work and probably I should just hand a delay over to the functions instead of putting it into the struct. But to my surpise even if I accept I couldn't use the timer from outside the struct, it wouldn't work:

```rust
struct TinyTimer<'a> {
    t: &'a mut (dyn delay::DelayUs<u32> + 'a),
}

impl<'a> TinyTimer<'a> {
    fn my_delay(&'a mut self, delay_time: u32) {
        self.t.delay_us(delay_time);
    }
}
```
I can put this into main and cargo doesn't complain:
```rust
    let mut t3 = dp.TIM4.delay_us(&clocks);
    t3.delay_us(1_000_000_u32);
    let mut tini = TinyTimer { t: &mut t3 };

```
To my very suprise, if I add the following it would be okay:
```rust
    tini.my_delay(1_000_000_u32);
    t3.delay_us(1_000_000_u32);
```
But this would not be okay:
```rust
    tini.my_delay(1_000_000_u32);
    tini.my_delay(1_000_000_u32);
```
Probably it's really stupid thing I oversee. But I am still a beginner and especially the generic stuff is still quite tricky for me.