如何在Rust中通过Trait关联类型约束泛型类型

问题描述 #

需要定义泛型结构体HalfMesh，使其接收实现MeshData trait的抽象数据类型，并通过该类型的方法完成自身初始化，但编译时出现类型不匹配错误。

原始代码 #

struct Edge<MetaData>
{
    next_id: u64,
    prev_id: u64,
    pair_id: u64,

    vert_id: u64,

    face_id: u64,

    meta_data: MetaData,
}

impl<MetaData> Edge<MetaData>
{
    fn new(vert_id: u64, pair_id: u64, data: MetaData) -> Self
    {
        return Self {
            next_id: !0,
            prev_id: !0,
            pair_id,
            vert_id,
            face_id: !0,
            meta_data: data,
        };
    }
}

struct HalfMesh<
    VMetaData,
    EMetaData,
    FMetaData,
> {
    verts: Vec<Vert<VMetaData>>,
    edges: Vec<Edge<EMetaData>>,
    faces: Vec<Face<FMetaData>>,
}

impl<V, E, F> HalfMesh<V, E, F>
{
    fn new_mesh<T>(data: T)
    where T :MeshData
    {
        let topology = data.get_topology();
        let half_edges = HashMap::<(u64, u64), usize>::new();

        let verts = Vec::<Vert<V>>::new();
        let edges = Vec::<Edge<E>>::new();
        let faces = Vec::<Face<F>>::new();

        for (face_id, face) in topology.iter().enumerate()
        {
            for i in 0..face.len()
            {
                let face_id = face_id as u64;
                let edge1 = (face[i], face[(i + 1) % face.len()]);
                if half_edges.contains_key(&edge1)
                {
                    continue;
                }

                let n = edges.len() as u64;
                edges.push(Edge::new(n + 1, edge1.0, data.get_edge_data(face_id, i as u64)));
            }
        }
    }
}

trait MeshData
{
    type VertData;
    type EdgeData;
    type FaceData;

    fn get_vert_data(&self, vert_id: u64) -> Self::VertData;
    fn get_edge_data(&self, face_id: u64, edge_id: u64) -> Self::EdgeData;
    fn get_face_data(&self, face_id: u64) -> Self::FaceData;

    fn get_topology(&self) -> &Vec<Vec<u64>>;
}

编译错误 #

64 | impl<V, E, F> HalfMesh<V, E, F>
   |         - this type parameter
...
88 |                 edges.push(Edge::new(n + 1, edge1.0, data.get_edge_data(face_id, i as u64)));
   |                            ---------                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected type parameter `E`, found associated type
   |                            |
   |                            arguments to this function are incorrect

错误原因 #

HalfMesh的泛型参数V、E、F和MeshData的关联类型VertData、EdgeData、FaceData之间没有建立约束关系，编译器无法确认data.get_edge_data()返回的T::EdgeData就是HalfMesh要求的E类型。

解决方案 #

需要在new_mesh方法的where约束中，明确绑定HalfMesh的泛型参数与MeshData的关联类型一致：

修改后的代码 #

use std::collections::HashMap;

// 补充原始代码中缺失的Vert和Face结构体定义
struct Vert<MetaData> {
    meta_data: MetaData,
}

struct Face<MetaData> {
    meta_data: MetaData,
}

struct Edge<MetaData>
{
    next_id: u64,
    prev_id: u64,
    pair_id: u64,

    vert_id: u64,

    face_id: u64,

    meta_data: MetaData,
}

impl<MetaData> Edge<MetaData>
{
    fn new(vert_id: u64, pair_id: u64, data: MetaData) -> Self
    {
        Self {
            next_id: !0,
            prev_id: !0,
            pair_id,
            vert_id,
            face_id: !0,
            meta_data: data,
        }
    }
}

struct HalfMesh<VMetaData, EMetaData, FMetaData> {
    verts: Vec<Vert<VMetaData>>,
    edges: Vec<Edge<EMetaData>>,
    faces: Vec<Face<FMetaData>>,
}

impl<V, E, F> HalfMesh<V, E, F>
{
    fn new_mesh<T>(data: T) -> Self
    where 
        T: MeshData,
        // 明确绑定HalfMesh泛型与MeshData的关联类型
        V: From<T::VertData>,
        E: From<T::EdgeData>,
        F: From<T::FaceData>,
    {
        let topology = data.get_topology();
        let mut half_edges = HashMap::<(u64, u64), usize>::new();

        let mut verts = Vec::<Vert<V>>::new();
        let mut edges = Vec::<Edge<E>>::new();
        let mut faces = Vec::<Face<F>>::new();

        // 初始化顶点数据（示例逻辑，可按需调整）
        if let Some(&max_vert_id) = topology.iter().flatten().max() {
            for vert_id in 0..=max_vert_id {
                let vert_data = data.get_vert_data(vert_id);
                verts.push(Vert { meta_data: V::from(vert_data) });
            }
        }

        for (face_idx, face) in topology.iter().enumerate()
        {
            let face_id = face_idx as u64;
            // 初始化面数据
            let face_data = data.get_face_data(face_id);
            faces.push(Face { meta_data: F::from(face_data) });

            for i in 0..face.len()
            {
                let edge1 = (face[i], face[(i + 1) % face.len()]);
                if half_edges.contains_key(&edge1)
                {
                    continue;
                }

                // 添加半边边
                let edge_data = data.get_edge_data(face_id, i as u64);
                let n = edges.len() as u64;
                edges.push(Edge::new(n + 1, edge1.0, E::from(edge_data)));
                half_edges.insert(edge1, edges.len() - 1);

                // 处理配对边（示例逻辑，可按需调整）
                let edge_pair = (edge1.1, edge1.0);
                if !half_edges.contains_key(&edge_pair) {
                    let pair_n = edges.len() as u64;
                    edges.push(Edge::new(pair_n + 1, edge1.1, E::from(data.get_edge_data(face_id, i as u64))));
                    half_edges.insert(edge_pair, edges.len() - 1);
                }
            }
        }

        Self { verts, edges, faces }
    }
}

trait MeshData
{
    type VertData;
    type EdgeData;
    type FaceData;

    fn get_vert_data(&self, vert_id: u64) -> Self::VertData;
    fn get_edge_data(&self, face_id: u64, edge_id: u64) -> Self::EdgeData;
    fn get_face_data(&self, face_id: u64) -> Self::FaceData;

    fn get_topology(&self) -> &Vec<Vec<u64>>;
}

关键修改点 #

1. 类型约束绑定：在new_mesh的where约束中添加：

   • V: From<T::VertData>：允许将MeshData的顶点数据转换为HalfMesh的顶点元数据类型
   • E: From<T::EdgeData>：允许将MeshData的边数据转换为HalfMesh的边元数据类型
   • F: From<T::FaceData>：允许将MeshData的面数据转换为HalfMesh的面元数据类型
     如果元数据类型完全一致，也可以直接用V = T::VertData、E = T::EdgeData、F = T::FaceData进行绑定。

2. 补充缺失定义：添加了原始代码中未给出的Vert和Face结构体，保证代码可编译。

3. 完善初始化逻辑：补充顶点、面的初始化逻辑，修改方法返回Self以完成HalfMesh的实例化，同时添加配对边的处理逻辑（可根据实际拓扑需求调整）。

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