CODEWITHSUNDEEP
rust
John Smith
John Smith

Reputation: 2332

Casting unknown type to know type

So I have this function

fn render_i32(n: &dyn Typeable, echo: &dyn Fn(&String)) {
    let x: &i32 = unsafe {transmute(n)};
    echo(&x.to_string());
}

It does not compile because cannot transmute between types of different sizes.

What I want with this code is the following: I have a HashMap which contains rendering functions for different types. Every type that may be rendered must implement my interface Typeable, which basically only returns a constant type_id for the type (I've just come across a type_id in std, and wonder if I could use that instead...). And using that type_id I can then look up the correct render function in my HashMap. So my code ensures, that render_i32 is only called for i32. This works fine.

Now all of this would be really easy in C where I'd just cast the value under the pointer. But in rust it does not appear to be so easy. I don't get at the i32 value. How would I get that?

Edit: Alternative Solutions to my own approach that are less type-unsafe but solve the following requirement are also welcome: clients (who use this library) should be able to add their own rendering functions for their own types...

Note that the rendering functions are not supposed to be statically defined once: different rendering functions might be used for the same type depending for example on a language setting.

Upvotes: 3

Views: 2505

Answers (2)

Alexey S. Larionov
Alexey S. Larionov

Reputation: 7927

I still don't get why you didn't use the conventional trait-impl approach, it seems to do what you wanted, except that function pointers don't have any common data structure holding them (it's probably less cache-friendly than HashMap's approach)

Playground

use std::iter;

// lib
fn echo_windows(s: &String) {
    println!("C:/Users> {}", s)
}

fn echo_linux(s: &String) {
    println!("$ {}", s)
}

trait Renderable {
    fn render(&self, echo: &dyn Fn(&String));
}

// client
struct ClientType {
    ch: char,
    len: usize,
}

impl Renderable for ClientType {
    fn render(&self, echo: &dyn Fn(&String)) {
        let to_echo: String = iter::repeat(self.ch)
            .take(self.len)
            .collect();
        echo(&to_echo);
    }
}


fn main() {
    ClientType{ ch: '#', len: 5 }.render(&echo_windows); // output: C:/Users> #####
    ClientType{ ch: '!', len: 3 }.render(&echo_linux);   // output: $ !!!
}

Upvotes: 2

Román Cárdenas
Román Cárdenas

Reputation: 552

Maybe you can use the Any trait for your purpose:

use std::any::Any;

pub trait Typeable {
   ...
   fn as_any(&self) -> &dyn Any;
}

fn render_i32(n: &dyn Typeable, echo: &dyn Fn(&String)) {
    let x: &i32 = n.as_any().downcast_ref::<i32>().unwrap();
    echo(&x.to_string());
}

The downcast_ref::<i32>() method returns an Option<&i32>, so you can also check if the downcast is valid. You can even do this in a generic way:

fn render<T:'static + std::fmt::Display>(n: &dyn Typeable, echo: &dyn Fn(&String)) {
    let x: &T = n.as_any().downcast_ref::<T>().unwrap();
    echo(&x.to_string());
}

Upvotes: 2

Related Questions