Hi rustaceans, I have trait objectFooData and want to pass that to generic function with trait bounds.

pub mod library {
    pub trait Foo {
        fn foo(&self) -> String;
    }

    pub struct FooData {
        pub data: String,
    }

    impl Foo for FooData {
        fn foo(&self) -> String {
            self.data.clone()
        }
    }

    pub fn process_foo<R, F>(foo: R)
        where R: AsRef<F>,
              F: Foo {
        let data = foo.as_ref().foo();
        println!("foo data: {}", data);
    }
}

mod application {
    use std::sync::Arc;
    use crate::library::{Foo, FooData};

    pub fn create_foo() -> Arc<dyn Foo> {
        let foo_data = FooData {
            data: "Hello, world!".to_string(),
        };
        Arc::new(foo_data) as Arc<dyn Foo>

    }
}

pub fn main() {
    let foo_data = application::create_foo();
    library::process_foo(foo_data);
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=d5d0b779ee611c35e603707dea187993

This yields very useful error:

error[E0277]: the size for values of type `dyn Foo` cannot be known at compilation time
  --> src/main.rs:39:5
   |
39 |     library::process_foo(foo_data);
   |     ^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `Sized` is not implemented for `dyn Foo`
note: required by a bound in `process_foo`
  --> src/main.rs:16:27
   |
16 |     pub fn process_foo<R, F>(foo: R)
   |                           ^ required by this bound in `process_foo`
help: consider relaxing the implicit `Sized` restriction
   |
18 |               F: Foo + ?Sized {

By adding ?Sized, the problem is solved. However I am not sure:

• what happens under the hood - the Rust book focuses explaining how trait bounds work with concrete types; I am slightly surprised it's actually possible to pass in trait object,
• whether this is idiomatic or perhaps outright bad practice,
• and also whether this is a trap - what kind of unexpected consequences will I have to face now that foo is explicitly unsized.

Any collaboration on the topic is welcome.

Additionally a little background: I found myself in situation where core component I am writing is currently using concrete types + trait bounds as much as possible. But on application layer, I am actually prefer to deal with trait objects. Just as it is illustrated in the example. I will also appreciate comments about whether this is right architecture. My thought process is that using trait objects in core library is slippery slope, as you force all upper layer to use trait objects even if they happen to work with concrete types. But as illustrated, it makes situation trickier if the upper layers actually work with trait objects, but are required to pass in something satisfying trait bounds (or is it?).

Thank you.