如何使用Rust枚举，结构，特征或其他任何东西来构造包含存在类型的值？

Question

What Rust construct roughly accomplishes the same thing as the following OCaml?

type t = F : 'x * ('x -> string) -> t

let int_eg = F(1, string_of_int)
let str_eg = F("foo", fun x -> x)

let print x = print_string (match x with
  | F(x,to_str) -> to_str x)

Answer 1

The closest thing you can get to existential types are trait objects:

// how ToString is declared
trait ToString {
    fn to_string(&self) -> String;
}

let i32_str: Box<ToString> = Box::new(1);
let str_str: Box<ToString> = Box::new("foo");

fn print(value: &ToString) -> String {
    value.to_string()
}
print_x(&i32_str);  // automatically coerced from Box<ToString> to &ToString
print_x(&str_str);

With trait objects, the actual type is erased, and the only thing that remains is the knowledge that this particular value is of some type which implements the given trait. It is very similar to existential types with type class bounds in Haskell:

data Showable = Showable (forall a. Show a => a)

There is no way to bundle an arbitrary function with an arbitrary type, erasing it from the container signature, so you need to use a trait for it. Fortunately, traits are easy to define and implement for arbitrary types, so you can always define a trait and use a trait object. Trait objects cover almost all functionality for which existentials are usually needed in ML/Haskell.

Moreover, in many cases you don't need to work with trait objects at all! For example, the print() function above should actually be written as follows:

fn print<T: ToString>(value: &T) -> String {
    value.to_string()
}

Such function is much more powerful because it works with arbitrary implementors of ToString trait, which include trait objects made out of ToString but also everything else which implements ToString . The only place you usually use trait objects is when you define heterogeneous data structures:

let many_to_strings: Vec<Box<ToString>> = vec![Box::new(1), Box::new("foo")];

But, as I said above, when you consume trait objects, in most cases you don't need to specify that you need a trait object - a regular generic function would be more idiomatic.