如何反序列化爲特徵，而不是具體類型？

Question

我想要做的結構序列化，其中的字節最終將被髮送到一個管道，重建和調用方法。

我創建了一個特點，這些結構將實施適當的和我使用SERDE和SERDE-CBOR序列化：

extern crate serde_cbor; 
#[macro_use] 
extern crate serde_derive; 
extern crate serde; 

use serde_cbor::ser::*; 
use serde_cbor::de::*; 

trait Contract { 
    fn do_something(&self); 
} 

#[derive(Debug, Serialize, Deserialize)] 
struct Foo { 
    x: u32, 
    y: u32, 
} 

#[derive(Debug, Serialize, Deserialize)] 
struct Bar { 
    data: Vec<Foo>, 
} 

#[derive(Debug, Serialize, Deserialize)] 
struct Baz { 
    data: Vec<Foo>, 
    tag: String, 
} 

impl Contract for Bar { 
    fn do_something(&self) { 
     println!("I'm a Bar and this is my data {:?}", self.data); 
    } 
} 

impl Contract for Baz { 
    fn do_something(&self) { 
     println!("I'm Baz {} and this is my data {:?}", self.tag, self.data); 
    } 
} 

fn main() { 
    let data = Bar { data: vec![Foo { x: 1, y: 2 }, Foo { x: 3, y: 4 }, Foo { x: 7, y: 8 }] }; 
    data.do_something(); 

    let value = to_vec(&data).unwrap(); 
    let res: Result<Contract, _> = from_reader(&value[..]); 
    let res = res.unwrap(); 
    println!("{:?}", res); 
    res.do_something(); 
} 

當我試圖重建使用特徵作爲類型字節（假設我不知道哪個基礎對象被髮送），編譯器會抱怨的特質沒有實現Sized特點：

error[E0277]: the trait bound `Contract: std::marker::Sized` is not satisfied 
    --> src/main.rs:52:15 
    | 
52 |  let res: Result<Contract, _> = from_reader(&value[..]); 
    |    ^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Sized` is not implemented for `Contract` 
    | 
    = note: `Contract` does not have a constant size known at compile-time 
    = note: required by `std::result::Result` 

我想這是有道理的，因爲編譯器不知道結構應該有多大，不知道如何排列它的字節。如果我改線，我反序列化對象指定實際的結構類型，它的工作原理：

let res: Result<Bar, _> = from_reader(&value[..]); 

有沒有更好的方式來實現這一系列化+多態行爲？

Answer 1

它看起來像是陷入了我從C++轉移到Rust時陷入的陷阱。嘗試使用多態來建模一組固定類型的變體。 Rust的枚舉（類似於Haskell的枚舉，相當於Ada的變體記錄類型）與其他語言中的經典枚舉不同，因爲枚舉變體可以擁有自己的字段。

我建議你改變你的代碼

#[derive(Debug, Serialize, Deserialize)] 
enum Contract { 
    Bar { data: Vec<Foo> }, 
    Baz { data: Vec<Foo>, tag: String }, 
} 

#[derive(Debug, Serialize, Deserialize)] 
struct Foo { 
    x: u32, 
    y: u32, 
} 

impl Contract { 
    fn do_something(&self) { 
     match *self { 
      Contract::Bar { ref data } => println!("I'm a Bar and this is my data {:?}", data), 
      Contract::Baz { ref data, ref tag } => { 
       println!("I'm Baz {} and this is my data {:?}", tag, data) 
      } 
     } 
    } 
}