标签: traits

我正在特征上实现调试特征。我希望能够显示实现此特定特征实例的具体类型的名称。

trait Node {
    foo: String,
}
    
impl fmt::Debug for dyn Node {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let name = // get type name of self here
        write!(f, "The name: {}", name);
    }
}

我读过很多关于 Any 和 downcasting 之类的文章，但这些解决方案看起来很复杂。

一种可能的解决方案是向特征本身添加一个方法：get_name() -> String，并为每个结构单独实现它。不过，必须有一种更简单的方法。

我无法让以下代码工作（游乐场：https://play.rust-lang.org/? version=stable&mode= debug&edition=2021&gist=4379c2006dcf3d32f59b0e44626ca667）。

use serde::{Serialize, Deserialize};

trait InnerStruct<'delife>: Deserialize<'delife> + Serialize {}

#[derive(Serialize, Deserialize)]
struct InnerStructA{
    a: i32
}

impl InnerStruct<'_> for InnerStructA {}

#[derive(Serialize, Deserialize)]
struct InnerStructB{
    a: i32,
    b: i32
}

impl InnerStruct<'_> for InnerStructB {}

#[derive(Serialize, Deserialize)]
struct OuterStruct<T: InnerStruct>{   // Remove the word "InnerStruct" and this works
    c: f64,
   inner: T
}

fn print_json<T: for<'a> InnerStruct<'a>>(obj: T) {
    println!("Serde JSON: {:?}", serde_json::to_string(&obj).unwrap());
}

fn main() {
    let inner_a = InnerStructA{a: 123};
    let inner_b = InnerStructB{a: …

这是我的代码，它可以编译

trait AppendBar {
    fn append_bar(self) -> Self;
}

impl AppendBar for Vec<String> {
    fn append_bar(mut self) -> Self {
        self.push("Bar".to_string());
        self
    }

虽然它获取了所有权，但是为什么它可以在实现过程中改变 self 呢？

我实现了结构Deref的特征，它允许我通过orMyString使用类型的对象。MyString*oo.deref()

但是，当我实现该Drop特征MyString时，已经实现的Deref特征就不能在该特征内部使用Drop。为什么？

use std::ops::Deref;
use std::ops::DerefMut;

struct MyString {
    s: String,
}

impl Deref for MyString {
    type Target = String;

    fn deref(&self) -> &Self::Target {
        &self.s
    }
}

impl DerefMut for MyString {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.s
    }
}

impl Drop for MyString {
    fn drop(&mut self) {
        // println!("string dropped: {}", *self); // `MyString` doesn't implement `std::fmt::Display`
        // …

在课程期间https://class.coursera.org/reactive-001/class我遇到了这样的结构:

trait Generator[+T] {
  def generate: T
}

和用法:

val integers = new Generator[Int] {
  val rand = new java.util.Random
  def generate = rand.nextInt()
}

为什么我们能做到这一点？哪里可以找到更多相关信息？

我正在尝试使用泛型,但我不能很好地掌握该主题,并且我收到此错误:

error: mismatched types:
expected `book::mdbook::MDBook<R>`,
found `book::mdbook::MDBook<renderer::html_handlebars::HtmlHandlebars>`
(expected type parameter,
found struct `renderer::html_handlebars::HtmlHandlebars`) [E0308]

这是相关的代码

pub struct MDBook<R> where R: Renderer {
    title: String,
    author: String,
    config: BookConfig,
    pub content: Vec<BookItem>,
    renderer: R,
}

impl<R> MDBook<R> where R: Renderer {

    pub fn new(path: &PathBuf) -> Self {

        MDBook {
            title: String::from(""),
            author: String::from(""),
            content: vec![],
            config: BookConfig::new()
                        .set_src(path.join("src"))
                        .set_dest(path.join("book")),
            renderer: HtmlHandlebars::new(), // <---- ERROR HERE
        }
    }
}

该Renderer特征目前是空的,实现HtmlHandlebars是

pub struct HtmlHandlebars;

impl Renderer for …

特征比行为更有效,因为行为是兼顾时间和记忆的对象.任何人都可以解释我如何在yii2中写出特征？

我正在学习Rust,我在实现多态方面遇到了困难.我想用数组来存储Circle或者Test.

trait Poli {
    fn area(&self) -> f64;
}

struct Circle {
    x:      f64,
    y:      f64,
    radius: f64,
}

impl Circle {
    fn new (xx: f64, yy: f64, r: f64) -> Circle{
        Circle{ x: xx, y: yy, radius: r }
    }
}

impl Poli for Circle {
   fn area(&self) -> f64 {
       std::f64::consts::PI * (self.radius * self.radius)
   }
}

struct Test {
    x:      f64,
    y:      f64,
    radius: f64,
    test:   f64,
}

impl Test {
    fn new …

我正在为Rust构建一个Raft一致性算法中间件,它具有与copycat类似的架构.我为开发人员编写了一个宏来定义命令方案.宏生成具有用户定义命令A的dispatch函数的特征,这需要开发人员为其行为实现结构,并且编码器/解码器与该主题无关.

特征Server对象向对象注册以使其工作.因为trait A是动态生成的,所以我必须将另一个特征定义B为父特征A.Server作品有B调用dispatch中定义的函数A.

我尝试了不同的组合,但没有一个有效.

trait B {
    fn dispatch(&mut self, fn_id: u64) -> Vec<u8>;
}

// macro generated trait
trait A: B {
    fn a(&self) -> Vec<u8>;
    fn b(&self) -> Vec<u8>;
    fn dispatch(&mut self, fn_id: u64) -> Vec<u8> {
        match fn_id {
            1 => a(),
            2 => b(),
            _ => {}
        }
    }
}

不幸的是,dispatch在功能上A不会执行 …

我有以下片段的Rust:

pub fn scope(&mut self) -> &mut HashMap<String, Type> {
    let idx = self.vars.len() - 1;
    &mut self.vars[idx]
}

我已经意识到我有一些上下文,我想在函数的非可变版本中使用此函数,例如:

pub fn scope(&self) -> &HashMap<String, Type> {
    let idx = self.vars.len() - 1;
    &self.vars[idx]
}

mut两个功能之间只删除了3 秒.我可以以某种方式将这些变成一个函数,根据可变性来推导我返回的引用的可变性self吗？是否有一些我可以使用或类似的特征？