rust - 枚举和结构上可编码的性状边界问题

以Rust进行试驾。到目前为止，它很有趣，但是我不确定如何在这种情况下设置特征范围来做一些有用的事情。



在我看来，我需要为枚举List<T: Encodable>设置一个界限。但是，当我尝试这样做时，编译器会有点不高兴。



所以我以为我必须对实现impl<T:Encodable>设置界限，但是得到了这个……



如果是这样，我将如何在Rust中做类似的事情？

extern crate serialize;
use serialize::{ json, Encodable };

#[deriving(Decodable, Encodable)]
pub enum List<T> {
    Node(T, Box<List<T>>),
    Nil
}

impl<T> List<T> {
fn to_json(&self) -> String {
    json::Encoder::str_encode(self)
}
}

当我工作时似乎工作正常，不要尝试封装编码，因为它知道int是可编码的...

let mut list: List<int> = Nil;
...
let encoded_string = json::Encoder::str_encode(&list);
println!("{}", encoded_string);

最佳答案

目前，边界不能放在结构和枚举上。这可能会改变，但是直到那时，impl才是您定义这些约束的地方。

让我们看一下特征的定义: Encodable<S: Encoder<E>, E> 。 S和E是它提示的东西，希望您对其进行定义。

现在，我们来看看#[deriving(Encodable)]的功能，方法是使用rustc --pretty expanded编译代码，该代码会扩展该属性。

#![feature(phase)]
#![no_std]
#![feature(globs)]
#[phase(plugin, link)]
extern crate std = "std#0.11.0-pre";
extern crate native = "native#0.11.0-pre";
extern crate serialize;
use std::prelude::*;
use serialize::{json, Encodable};

pub enum List<T> { Node(T, Box<List<T>>), Nil, }
#[automatically_derived]
impl <__S: ::serialize::Encoder<__E>, __E,
      T: ::serialize::Encodable<__S, __E>> ::serialize::Encodable<__S, __E>
     for List<T> {
    fn encode(&self, __arg_0: &mut __S) -> ::std::result::Result<(), __E> {
        match *self {
            Node(ref __self_0, ref __self_1) => {
                let _e = __arg_0;
                _e.emit_enum("List",
                             |_e|
                                 _e.emit_enum_variant("Node", 0u, 2u, |_e| {
                                                      match _e.emit_enum_variant_arg(0u,
                                                                                     |_e|
                                                                                         (*__self_0).encode(_e))
                                                          {
                                                          Ok(__try_var) =>
                                                          __try_var,
                                                          Err(__try_var) =>
                                                          return Err(__try_var)
                                                      };
                                                      return _e.emit_enum_variant_arg(1u,
                                                                                      |_e|
                                                                                          (*__self_1).encode(_e));
                                                  }))
            },
            Nil => {
                let _e = __arg_0;
                _e.emit_enum("List",
                             |_e|
                                 _e.emit_enum_variant("Nil", 1u, 0u, |_e| {
                                                      return ::std::result::Ok(());
                                                  }))
            }
        }
    }
}
#[automatically_derived]
impl <__D: ::serialize::Decoder<__E>, __E,
      T: ::serialize::Decodable<__D, __E>> ::serialize::Decodable<__D, __E>
     for List<T> {
    fn decode(__arg_0: &mut __D) -> ::std::result::Result<List<T>, __E> {
        __arg_0.read_enum("List",
                          |_d|
                              _d.read_enum_variant(["Node", "Nil"],
                                                   |_d, i|
                                                       ::std::result::Ok(match i
                                                                             {
                                                                             0u
                                                                             =>
                                                                             Node(match _d.read_enum_variant_arg(0u,
                                                                                                                 |_d|
                                                                                                                     ::serialize::Decodable::decode(_d))
                                                                                      {
                                                                                      Ok(__try_var)
                                                                                      =>
                                                                                      __try_var,
                                                                                      Err(__try_var)
                                                                                      =>
                                                                                      return Err(__try_var)
                                                                                  },
                                                                                  match _d.read_enum_variant_arg(1u,
                                                                                                                 |_d|
                                                                                                                     ::serialize::Decodable::decode(_d))
                                                                                      {
                                                                                      Ok(__try_var)
                                                                                      =>
                                                                                      __try_var,
                                                                                      Err(__try_var)
                                                                                      =>
                                                                                      return Err(__try_var)
                                                                                  }),
                                                                             1u
                                                                             =>
                                                                             Nil,
                                                                             _
                                                                             =>
                                                                             ::std::rt::begin_unwind("internal error: entered unreachable code",
                                                                                                     "s.rs",
                                                                                                     4u)
                                                                         })))
    }
}

impl <T> List<T> {
    fn to_json(&self) -> String { json::Encoder::str_encode(self) }
}

是的，这很困惑。但是它显示了Encodable实现和正在编写的边界。基本上，约束是由您以相同的方式编写的:您不必关心任何特定的类型，只需要一个编码器即可。那么，这可以归结为:

impl<S: Encoder<E>, E, T: Encodable<S, E>> Encodable<S, E> for List<T> {
    fn encode(&self, encoder: &mut S) -> Result<(), E> {
        …
    }
}

关于rust - 枚举和结构上可编码的性状边界问题，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/24443768/