最近发现一种 Rust 的设计模式，有点好玩，发出来大家探讨一下。示例如下：

use std::ops::Deref;

trait TraitFoo {
fn foo(&self);
}

struct A;

impl TraitFoo for A {
fn foo(&self) {
println!("Huh, I'm foo!");
    }
}

struct B<T> {
    behavior: T
}

impl<T> B<T> {
pub fn new(behavior: T) -> B<T> {
	B {
	    behavior
	}
    }
}

impl<T> Deref for B<T> {
type Target = T;

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


trait TraitBar {
fn bar(&self);
}

struct C;

impl TraitBar for C {
fn bar(&self) {
println!("Huh, I'm bar!");
    }
}


fn main() {
let a = A;
let b = B::new(a);
    b.foo();

let c = C;
let b = B::new(c);
    b.bar();
}

运行结果：

Huh, I'm foo!
Huh, I'm bar!

大体意思就是，B 是一个类型，它接受一个泛型作为它的形参，然后“盗用”了它的实参的方法。

如果 B 实现为一个库，对外导出 B 类型，供别人使用。那么在上层用户来看，就可以很灵活地为这个导出类型的实例添加“额外”的方法。而这些方法，并不是使用通常的为“外部类型”实现“本地 trait”的技术来达到。而是通过将本地实现的类型的实例作为参数传入 B 的构造器来达到。感觉有点意思。

小编才疏学浅，不知道社区中以前有没有过对此种设计模式的讨论，或者其它语言中有没有对应的模式，是不是已命名？大家一起讨论。

ITPub博客

【Rust每周一知】一种 Rust 设计模式

最新文章

ITPub博客

【Rust每周一知】 一种 Rust 设计模式

最新文章

【Rust每周一知】一种 Rust 设计模式