No cost abstraction

help
1

Why I am not able to monomorphise a trait in a struct member

trait Callback{
    fn on_recv(&self, msg: &[u8]);
}
struct LoggerCallback;

impl Callback for LoggerCallback{
    fn on_recv(&self, msg: &[u8]){
        println!("LoggerCallback: {:?}", msg);
    }
}

struct Clt2;
impl Clt2{
    fn new(callback: impl Callback) -> Self{  // --> WORKS
        println!("Clt2::new");
        Self{}
    }
}

struct Clt{
    callback: impl Callback, // --> DOES NOT WORK
}

fn main(){
    println!("Hello, world!");
}
2

What do you expect it to do? In a global context, there's nothing to infer the type from, so this doesn't make much sense.

2 Likes
3

Did you mean

struct Clt<T: Callback> {
  callback: T,
}

?

2 Likes
4

I would like to be able to create different implementations of the Callback trait and pass it into the Clt so a call back can for example just log or just capture msg into a memory map, etc. Here is more to complete this example

trait Callback{
    fn on_recv(&self, msg: &[u8]);
}
struct LoggerCallback;

impl Callback for LoggerCallback{
    fn on_recv(&self, msg: &[u8]){
        println!("LoggerCallback: {:?}", msg);
    }
}

struct Clt2;
impl Clt2{
    fn new(callback: impl Callback) -> Self{  // --> WORKS
        println!("Clt2::new");
        Self{}
    }
}

struct Clt{
    callback: impl Callback, // --> DOES NOT WORK
}
impl Clt{
    fn new(callback: impl Callback) -> Self{
        Self{ callback }
    }
    fn send(&self, msg: &[u8]){
        self.callback.on_recv(msg);
    }
}

struct Logger{

}
impl Logger{
    fn new() -> Self{
        Self{}
    }
}
impl Callback for Logger{
    fn on_recv(&self, msg: &[u8]){
        println!("Logger: {:?}", msg);
    }
}

struct Cacher<'a>{
    store: Vec<&'a [u8]>
}

impl<'a> Cacher<'a>{
    fn new() -> Self{
        Self{ store : Vec::new()}
    }
}
impl<'a> Callback for Cacher<'a>{
    fn on_recv(&self, msg: &[u8]){
        self.store.push(msg);
    }
}

fn main(){
    let logger = Logger::new();
    let clt = Clt::new(logger);
    clt.send(&b"to the log"[..]);

    // vs

    let cacher = Cacher::new();
    let clt = Clt::new(cacher);
    clt.send(&b"to the store"[..]);

    println!("Hello, world!");
}
5

The problem with this approach is it passes a type but I need an instance of that type

6

If you don't want to parameterize your struct with a generic type, you'll need to either pick a specific implementing type or type erase implementing types.

You can erase implementing types with dyn Callback + '_. Here's one possible way, wherein the implementing type must also be 'static:

trait Callback {
    fn on_recv(&self, msg: &[u8]);
}

struct Clt {
    callback: Box<dyn Callback>,
}

impl Clt {
    fn new(callback: impl Callback + 'static) -> Self {
        let callback = Box::new(callback);
        Self { callback }
    }
}

N.b. there were some unrelated borrower errors around Cacher<'_> which I have ignored in this comment [1].

Note that this:

impl Clt {
    fn new(callback: impl Callback + 'static) -> Self {

Is a (arguably slightly) less capable version of this:

impl Clt {
    fn new<C: Callback + 'static>(callback: C) -> Self {

which is to say, it introduces a generic type parameter to the function. So the more direct translation for Ctl is indeed to add a generic type parameter to the struct.

Syntactically hiding the fact that a struct is generic, not being able to fully name the type with its concrete parameters, etc. would be a lot more problematic for structs than it is for fns.

  1. but will probably give you grief within your current design ↩ī¸Ž

4 Likes
7

Thanks really, great suggestion but I am specifically trying to avoid dynamic dispatch in my case because the callback inside Clt struct is in the hot path.

8

Generics don't perform dynamic dispatch. You are confusing generics with trait objects.

3 Likes