Multilock doesn't seem to work in an infinite loop

[wt]

The following fails, while the commented version works:

    async fn blink(
        blink::Context {
            shared:
                blink::SharedResources {
                    mut red_led,
                    mut usb_serial,
                    ..
                },
            ..
        }: blink::Context,
    ) {
        loop {
            (&red_led, &usb_serial).lock(|led, s| {
                led.toggle().unwrap();
                let _ = s.write(b"fjdklsf");
            });
            // usb_serial.lock(|s| {
            //     red_led.lock(|led| {
            //         led.toggle().unwrap();
            //         let _ = s.write(b"fjdklsf");
            //     })
            // });
            Mono::delay(2u64.secs()).await;
       }
    }

I would have expected both of these to work.

[korken89]

Hi, you need you form the references outside the loop - else they are moved into the loop.

[wt]

@korken89:

I found the following works:

    {
        loop {
            (&mut red_led, &mut usb_serial).lock(|led, s| {
                led.toggle().unwrap();
                let _ = s.write(b"fjdklsf");
            });
            Mono::delay(2u64.secs()).await;
       }
    }

How does this correspond to you comment that I need to "form the references outside the loop"? Is this rust terminology?

BTW, this issue should probably be closed, but it might be worth adding an example in the multilock example that shows this scenario.

[korken89]

Yeah, the issue is that a tupe (by default) takes its members by move - so you must explicitly make references as you did now.
For some reason I thought this would not work, but this is a neater solution than what I had in mind - nice work!

[wt]

Thanks!

Should a new example of this be added so that there's at least an example somewhere?

[AfoHT]

Should a new example of this be added so that there's at least an example somewhere?

That sounds like a good idea, or perhaps as already suggested simply extending the multilock example.

Is this something you would be willing to add?

[wt]

Should a new example of this be added so that there's at least an example somewhere?

That sounds like a good idea, or perhaps as already suggested simply extending the multilock example.

Is this something you would be willing to add?

I'll try to find some time.