Rust实现无序字符串集合比较函数编译报错及解决咨询

问题背景 #

我想要实现一个用于比较两个字符串集合的函数，该函数需将集合视为无序进行比较。

在Python中，我会这样实现：

from collections.abc import Iterator

def unordered_eq(a: Iterator[str], b: Iterator[str]):
    a = sorted(a)
    b = sorted(b)
    assert a == b

我尝试在Rust中实现类似逻辑：将两个迭代器收集为新的Vec<&str>实例，分别调用sort()排序，最后通过assert_eq!(a, b)进行比较。

实现代码如下：

use std::ops::Deref;

fn unordered_eq<T, U, V, W>(a: T, b: V)
where
    T: Iterator<Item = U>,
    U: AsRef<str>,
    V: Iterator<Item = W>,
    W: AsRef<str>,
{
    let mut a: Vec<&str> = a.collect();
    let mut b: Vec<&str> = b.collect();
    a.sort();
    b.sort();
    assert_eq!(a, b);
}

fn main() {
    // Example usage:
    struct Item {
        path: String,
    }

    let items: Vec<Item> = vec![
        Item {path: String::from("hello")},
        Item {path: String::from("hello2")},
        Item {path: String::from("hello3")},
        Item {path: String::from("hello4")},
        Item {path: String::from("world")},
    ];

    unordered_eq(
        items.iter().map(|x| x.path.as_str()),
        ["hello", "hello2", "hello3", "hello4", "world"]
            .iter()
            .map(|x| x.deref()),
    );
}

编译代码时出现错误：

error[E0277]: a value of type `Vec<&str>` cannot be built from an iterator over elements of type `U`

疑问：既然U实现了AsRef<str>，应该可以转换为&str，为何会报错？该如何修复这个函数？

问题原因 #

AsRef<str> trait仅保证类型U可以通过as_ref()方法转换为&str，但collect()方法不会自动执行这个转换——它只会直接收集迭代器的原始元素类型。你的代码中迭代器元素是U，而目标类型是Vec<&str>，两者类型不匹配，因此编译报错。

修复方案 #

需要在收集前，通过map方法显式调用as_ref()，将迭代器中的每个元素转换为&str：

use std::ops::Deref;

fn unordered_eq<T, U, V, W>(a: T, b: V)
where
    T: Iterator<Item = U>,
    U: AsRef<str>,
    V: Iterator<Item = W>,
    W: AsRef<str>,
{
    let mut a: Vec<&str> = a.map(|item| item.as_ref()).collect();
    let mut b: Vec<&str> = b.map(|item| item.as_ref()).collect();
    a.sort();
    b.sort();
    assert_eq!(a, b);
}

fn main() {
    struct Item {
        path: String,
    }

    let items: Vec<Item> = vec![
        Item {path: String::from("hello")},
        Item {path: String::from("hello2")},
        Item {path: String::from("hello3")},
        Item {path: String::from("hello4")},
        Item {path: String::from("world")},
    ];

    unordered_eq(
        items.iter().map(|x| &x.path),
        ["hello", "hello2", "hello3", "hello4", "world"].iter(),
    );
}

额外优化 #

1. 简化调用代码：String和&str本身都实现了AsRef<str>，因此调用时无需额外的map转换，直接传入items.iter().map(|x| &x.path)和数组迭代器即可，省去deref()操作。
2. 增强函数灵活性：可以让函数返回布尔值而非直接断言，方便在不同场景中使用：

fn unordered_eq<T, U, V, W>(a: T, b: V) -> bool
where
    T: Iterator<Item = U>,
    U: AsRef<str>,
    V: Iterator<Item = W>,
    W: AsRef<str>,
{
    let mut a: Vec<&str> = a.map(|item| item.as_ref()).collect();
    let mut b: Vec<&str> = b.map(|item| item.as_ref()).collect();
    a.sort();
    b.sort();
    a == b
}

fn main() {
    struct Item {
        path: String,
    }

    let items: Vec<Item> = vec![
        Item {path: String::from("hello")},
        Item {path: String::from("hello2")},
        Item {path: String::from("hello3")},
        Item {path: String::from("hello4")},
        Item {path: String::from("world")},
    ];

    assert!(unordered_eq(
        items.iter().map(|x| &x.path),
        ["hello", "hello2", "hello3", "hello4", "world"].iter(),
    ));
}

内容的提问来源于stack exchange，提问作者James Wong