*const () 可以替代泛型，更加靈活。

一、 代碼

//use std::mem::transmute;
trait Work {fn process(&self);
}
struct Foo(String);impl Work for Foo {fn process(&self) {println!("process work  from Foo : {}", self.0);}
}
struct Bar(String);
impl Work for Bar {fn process(&self) {println!("process work  from Bar : {}", self.0);}
}
fn fn_foo(foo: &Foo){println!("call fn_foo, output ->{}", foo.0);
}
fn fn_bar(bar: &Bar){println!("call fn_bar, output ->{}", bar.0);
}
fn main() {let foo = Foo("foo".into());let bar = Bar("bar".into());let unsafe_fn_foo: unsafe fn(*const ()) = fn_const_ptr(fn_foo as fn(&Foo));process_method::<Foo>( unsafe_fn_foo,&foo);let unsafe_fn_bar: unsafe fn(*const ()) = fn_const_ptr(fn_bar as fn(&Bar));process_method::<Bar>(unsafe_fn_bar,&bar);let foo_ptr: *const () = data_const_ptr(&foo);let bar_ptr: *const () = data_const_ptr(&bar);process_data::<Foo>(foo_ptr);process_data::<Bar>(bar_ptr);
}fn process_data<T: Work>(data: *const ()) {let obj: *const T = data.cast::<T>();unsafe{(*obj).process()};
}
fn process_method<T>(f:  unsafe fn(*const ()),data:&T) {let ptr: *const () = data as *const T as _; // 這里"_"是 type eraseunsafe{f(ptr)};
}
fn data_const_ptr<T>(data: &T) -> *const () {unsafe {data as *const T as _ // 這里"_"是 type erase}
}
fn fn_const_ptr<T>(f: fn(&T)) -> unsafe fn(*const ()) {unsafe {std::mem::transmute(f)}
}

二、輸出結果

PS D:\my_program\type_erase> cargo run --releaseFinished `release` profile [optimized] target(s) in 0.02sRunning `target\release\type_erase.exe`
call fn_foo, output ->foo
call fn_bar, output ->bar
process work  from Foo : foo
process work  from Bar : bar