How do I create a Vec<T> where T: Into<_> in Rust? - rust

Question

This is my example code. I am trying to pass a Vec<T> to a function where T: Into<_>!
enum Test {
FN(Box<dyn Fn()>),
STR(String),
}
impl<F> From<F> for Test
where F: Fn() + 'static
{
fn from(f: F) -> Self {
Self::FN(Box::new(f))
}
}
impl From<String> for Test {
fn from(s: String) -> Self {
Self::STR(s)
}
}
fn main() {
into(vec![
|| println!("func 1"),
|| println!("func 2"),
String::from("string 1"),
]);
}
fn into<T>(v: Vec<T>)
where T: Into<Test>
{
for test in v {
let test = test.into();
match test {
Test::FN(func) => func(),
Test::STR(s) => println!("{}", s),
}
}
}
The error is at the second closure:
expected closure, found a different closure
The problem is that Into<_> can't be dyn because it is Sized, so that doesn't work!
I am hoping for an output of:
func 1
func 2
string 1
Any answers or ideas?!

Answer 1

Rust does not generally do type coercion automatically. You've defined your From implementations, but nothing is calling them. You'd need to change your function to be more along the lines of
fn main() {
into(vec![
Test::from(|| println!("func 1")),
Test::from(|| println!("func 2")),
Test::from(String::from("string 1")),
]);
}

Answer 2

Just because you create a Test enum does not mean that Rust will reconcile the type of your otherwise heterogenous vector to be Test. You must manually instantiate each enum variant (and put a Box around your closures):
fn main() {
let x: Vec<Test> = vec![
Test::FN(Box::new(|| println!("func 1"))),
Test::FN(Box::new(|| println!("func 2"))),
Test::STR(String::from("string 1")),
];
into(x);
}

Answer 3

Your idea is to have a Vec of objects all being convertable to test. Yet Vec requires objects of the same type:
each closure has a different type
String is different from closure types
An example with a Vec with elements of the same type could be a Vecof just one of your elements:
into(vec![|| println!("func 1")]);
into(vec![|| println!("func 2")]);
into(vec![String::from("string 1")]);
// each has one element of ONE type, this compiles and runs
or a Vec of multiple elements of the same type:
into(vec![String::from("string 1"), String::from("string 2")]);
// each has multiple element of ONE type (String), this compiles and runs
To get your example to compile you will have to wrap your items in a wrapper type (e.g. an enum) that implements Into<Test>.
Your concrete example already contains such a wrapper type (Test) and thus your example unfortunately gets trivial, because if you put already Tests in your Vec you will not have to call into on them any more (this is shown in the other examples).

Answer 4

Thank you for all the answers,
I found my own solution by creating my own MyInto trait:
trait MyInto {
fn my_into(&self) -> Test;
}
enum Test<'l> {
FN(&'l dyn Fn()),
STR(String),
}
impl<F> MyInto for F
where F: Fn() + 'static
{
fn my_into(&self) -> Test {
Test::FN(self)
}
}
impl MyInto for String {
fn my_into(&self) -> Test {
Test::STR(self.to_owned())
}
}
fn main() {
into(vec![
&|| println!("func 1"),
&|| println!("func 2"),
&String::from("string 1"),
]);
}
fn into(v: Vec<&dyn MyInto>) {
for test in v {
let test = test.my_into();
match test {
Test::FN(func) => func(),
Test::STR(s) => println!("{}", s),
}
}
}
The output is now:
func 1
func 2
string 1
It is now possible to use the dyn in &dyn MyInto, because MyInto is not Sized!