cannot satisfy `_: Runnable<dyn A, Arc<Mutex<Option<Box<dyn A>>>>>` - rust

Question

I designed a trait that can run things that are Lockable, that is, can be locked to produce Option<T>, and I implemented it for Arc<Mutex<Option<Box<T>>>>
use std::sync::{LockResult, PoisonError, MutexGuard, Arc, Mutex};
pub type LockableArc<T: ?Sized> = Arc<Mutex<Option<T>>>;
pub struct MutexGuardOptionRef<'a, T: ?Sized> {
pub mutex_guard: MutexGuard<'a, Option<Box<T>>>,
}
pub trait LockableOption<T: ?Sized>: Clone + Send {
fn lock(&self) -> LockResult<MutexGuardOptionRef<T>>;
}
pub trait Runnable<R: ?Sized, T: LockableOption<R> + Clone + Send + ?Sized> {
fn run(s: T) -> Result<(), ()>;
}
impl<T: ?Sized + Send> LockableOption<T> for LockableArc<Box<T>> {
fn lock(&self) -> LockResult<MutexGuardOptionRef<T>> {
unimplemented!()
}
}
pub trait A: Send{}
pub struct S{}
impl A for S{}
impl<R: A, T: LockableOption<R> + Clone + Send + 'static> Runnable<R, T>
for S
{
fn run(arc_rtsp: T) -> Result<(), ()> {
Ok(())
}
}
fn main() {
let r: LockableArc<Box<dyn A>> = Arc::new(Mutex::new(Some(Box::new(S{}))));
Runnable::run(r.clone());
//Runnable::<dyn A, LockableArc<Box<dyn A>>>::run(r.clone());
}
Playground
Error:
error[E0283]: type annotations needed
--> src/main.rs:39:5
|
14 | fn run(s: T) -> Result<(), ()>;
| ------------------------------- required by `Runnable::run`
...
39 | Runnable::run(r.clone());
| ^^^^^^^^^^^^^ cannot infer type
|
= note: cannot satisfy `_: Runnable<dyn A, Arc<Mutex<Option<Box<dyn A>>>>>`
I don't understand this error. First because I don't know what '_ is. It looks like it's the type passed to run as the only argument. So I tried to force the type:
Runnable::<dyn A, LockableArc<Box<dyn A>>>::run(r.clone());
but I get the same error. What is happening?

Answer 1

Runnable is a trait, so Runnable::run does not know which implementation of that trait to use. Use S::run instead.
S::run won't work because its implementation of Runnable requires that R: A whereas here R is dyn A. Just restrict R: ?Sized instead and you should be fine.
Therefore (playground):
use std::sync::{LockResult, PoisonError, MutexGuard, Arc, Mutex};
pub type LockableArc<T: ?Sized> = Arc<Mutex<Option<T>>>;
pub struct MutexGuardOptionRef<'a, T: ?Sized> {
pub mutex_guard: MutexGuard<'a, Option<Box<T>>>,
}
pub trait LockableOption<T: ?Sized>: Clone + Send {
fn lock(&self) -> LockResult<MutexGuardOptionRef<T>>;
}
pub trait Runnable<R: ?Sized, T: LockableOption<R> + Clone + Send + ?Sized> {
fn run(s: T) -> Result<(), ()>;
}
impl<T: ?Sized + Send> LockableOption<T> for LockableArc<Box<T>> {
fn lock(&self) -> LockResult<MutexGuardOptionRef<T>> {
unimplemented!()
}
}
pub trait A: Send{}
pub struct S{}
impl A for S{}
impl<R: ?Sized, T: LockableOption<R> + Clone + Send + 'static> Runnable<R, T>
for S
{
fn run(arc_rtsp: T) -> Result<(), ()> {
Ok(())
}
}
fn main() {
let r: LockableArc<Box<dyn A>> = Arc::new(Mutex::new(Some(Box::new(S{}))));
S::run(r.clone());
}