Rust 等效于具有相同通用参数约束的 Swift 扩展方法？

Question

In Swift, I can add method to a generic type with parameter equality constraint.

extension Optional where Wrapped == String {
    // Available only for `Optional<String>` type.
    func sample1() { ... }
}

How to do this in Rust?

---

Update

This feature is called Extensions with a Generic Where Clause .

I think this is basically same feature with Rust's impl with where clause without explicit trait.

trait OptionUtil {
    fn sample1(&self);
}

impl<T> OptionUtil for Option<T> where T:std::fmt::Debug {
    fn sample1(&self) {
        println!("{:#?}", self);
    }
}

Is equivalent (without explicit trait) to

extension Optional where Wrapped: DebugDescription {
    func sample1() {
        print("\(self)")
    }
}

Therefore, I thought this Rust code would work, but it doesn't work with an error. ( equality constraints are not yet supported in where clauses (see #20041) )

impl<T> OptionUtil for Option<T> where T == String {
    fn sample1(&self) {
        println!("{:#?}", self);
    }
}

Answer 1

You can just implement the trait for the concrete type Option<String> :

impl OptionUtil for Option<String> {
    fn sample1(self: &Self) {
        println!("{:#?}", self);
    }
}

I wrote crate, type_eq , which would let you write something that looks more like your Swift example. But it is identical to implementing the trait for Option<String> :

use type_eq::{Constrain, TypeEq};
use std::fmt::Debug;

trait OptionUtil {
    fn sample1(&self);
}

impl<T> OptionUtil for Option<T>
where
    Constrain: TypeEq<T, String>,
    T: Debug,
{
    fn sample1(&self) {
        println!("{:#?}", self);
    }
}

fn main() {
    let s = Some(String::from("hello"));
    println!("{:?}", s);
}

There are actually very few cases where this crate is useful. Most of the time the simpler code above will work, and is preferred.