如何在Julia中创建支持多派发的自定义OrderedDict类型MyOrderedDictA与MyOrderedDictB？

其实这个需求实现起来确实很直接，核心思路是基于组合而非继承来复用OrderedDict的功能，同时让自定义类型继承AbstractDict以保证兼容性，这样两个类型就能完全独立支持多派发了。下面是具体的实现步骤和代码：

1. 准备工作：导入依赖包 #

首先我们需要用到DataStructures.jl里的OrderedDict，所以先导入它：

using DataStructures

2. 定义第一个自定义类型 MyOrderedDictA #

我们创建一个结构体，继承AbstractDict，内部用一个OrderedDict字段存储实际数据，同时实现方便的构造函数：

struct MyOrderedDictA{K,V} <: AbstractDict{K,V}
    data::OrderedDict{K,V}
end

# 构造函数：支持直接传入键值对创建实例
MyOrderedDictA(kv::Pair...) = MyOrderedDictA(OrderedDict(kv...))
# 空实例构造函数
MyOrderedDictA() = MyOrderedDictA(OrderedDict())
# 支持从其他AbstractDict转换
MyOrderedDictA(d::AbstractDict) = MyOrderedDictA(OrderedDict(d))

3. 转发方法以复用OrderedDict的全部功能 #

为了不用手动实现OrderedDict的所有方法，我们可以用DataStructures提供的@forward宏，把方法调用转发到内部的data字段：

# 转发常用的字典方法到内部的OrderedDict实例
DataStructures.@forward MyOrderedDictA.data Base.length, Base.getindex, Base.setindex!, 
    Base.delete!, Base.keys, Base.values, Base.pairs, Base.empty!, 
    Base.haskey, Base.get, Base.get!, DataStructures.insert!

4. 定义第二个独立类型 MyOrderedDictB #

完全按照同样的逻辑创建第二个类型，确保它和MyOrderedDictA没有关联：

struct MyOrderedDictB{K,V} <: AbstractDict{K,V}
    data::OrderedDict{K,V}
end

# 同样实现构造函数
MyOrderedDictB(kv::Pair...) = MyOrderedDictB(OrderedDict(kv...))
MyOrderedDictB() = MyOrderedDictB(OrderedDict())
MyOrderedDictB(d::AbstractDict) = MyOrderedDictB(OrderedDict(d))

# 转发方法
DataStructures.@forward MyOrderedDictB.data Base.length, Base.getindex, Base.setindex!, 
    Base.delete!, Base.keys, Base.values, Base.pairs, Base.empty!, 
    Base.haskey, Base.get, Base.get!, DataStructures.insert!

5. 测试多派发与兼容性 #

现在我们可以验证两个类型的独立性和兼容性了：

测试多派发 #

定义两个针对不同类型的处理函数：

function process_dict(d::MyOrderedDictA)
    println("正在处理 MyOrderedDictA，包含$(length(d))个条目")
    return sum(values(d))
end

function process_dict(d::MyOrderedDictB)
    println("正在处理 MyOrderedDictB，包含$(length(d))个条目")
    return prod(values(d))
end

运行测试：

# 创建实例
a_dict = MyOrderedDictA(:a => 1, :b => 2, :c => 3)
b_dict = MyOrderedDictB(:x => 2, :y => 3, :z => 4)

# 调用多派发函数
println(process_dict(a_dict))  # 输出：正在处理 MyOrderedDictA... 6
println(process_dict(b_dict))  # 输出：正在处理 MyOrderedDictB... 24

测试AbstractDict兼容性 #

所有接收AbstractDict的函数都能直接使用这两个自定义类型，比如merge、filter等：

# 测试merge函数
merged_a = merge(a_dict, MyOrderedDictA(:d => 4))
println(merged_a)  # 输出 MyOrderedDictA(:a=>1, :b=>2, :c=>3, :d=>4)

# 测试filter函数
filtered_b = filter(p -> p.second > 2, b_dict)
println(filtered_b)  # 输出 MyOrderedDictB(:y=>3, :z=>4)

为什么这样实现？ #

• 继承AbstractDict：保证自定义类型能无缝兼容所有针对AbstractDict编写的函数，不用额外适配。
• 组合OrderedDict：通过内部字段复用OrderedDict的所有功能，避免了单继承的限制，同时让两个自定义类型完全独立，支持多派发。
• @forward宏：省去了手动实现几十种字典方法的麻烦，大幅减少代码量。

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