魔咕

moogle 是一个 Rust 关系编程库。

关系编程是 SQL 数据库使用的底层模型。在关系模型中，所有数据都使用全局集合来表示。

大多数语言可以很好地支持这个模型，因为它们支持并发写入器和迭代器，只要写入器不改变底层数据结构的形状。

moogle 的目标是使关系代码在 Rust 中的编写尽可能容易，就像在 Python 或 SQL 中编写一样。

动机

假设你正在开发一个游戏，NPC 收集物品，你想要跟踪每个 NPC 背包中的物品。

let mut inventory: HashMap<NPC, Vec<Item>> = BTreeMap::new();

这种表示有以下问题

• 如果 NPC 没有物品，你必须手动初始化 Vec
• 如果 NPC 没有物品了，你必须手动移除 Vec

许多人通过创建一个 MultiMap 类型来解决这两个问题

let mut inventory: MultiMap<NPC, Item> = MultiMap::new();

这个系统中的一些示例代码可能看起来像这样

inventory.insert(russell, stick);
inventory.insert(russell, beetle);
inventory.insert(russell, pokemon_card);
inventory.insert(jochen, pizza);

println!("Russell's items: {:?}", inventory.get(russell)); 
    // => stick, beetle, pokemon_card
println!("Jochen's items: {:?}", inventory.get(jochen));  
    // => pizza

然而，这个系统可能存在一些潜在的问题。

首先，多映射的简单实现可能在 Jochen 取走物品后未能从 Russell 的库存中取出物品

inventory.insert(jochen, stick);

println!("Russell's items: {:?}", inventory.get(russell)); 
    // => stick, beetle, pokemon_card
println!("Jochen's items: {:?}", inventory.get(jochen));  
    // => pizza, stick

这并不是理想的情况。你可以通过在调用 inventory.insert() 之前跟踪棍子被取走前的背包来解决这个问题，但最好是不必通过改变你的游戏逻辑来跟踪质量守恒。

moogle 通过跟踪“谁以前拥有这根棍子？”的答案来解决此问题，然后使用这个答案来清除以前的拥有者

let inventory: OneToMany<NPC, Item> = OneToMany::new();
inventory.fwd().insert(russell, stick);
inventory.fwd().insert(russell, beetle);
inventory.fwd().insert(russell, pokemon_card);
inventory.fwd().insert(jochen, pizza);

println!("Russell's items: {:?}", inventory.fwd().get(russell)); 
    // => stick, beetle, pokemon_card
println!("Jochen's items: {:?}", inventory.fwd().get(jochen));  
    // => pizza

println!("Who owns the stick? {:?}", inventory.bwd().get(stick));
    // => russell

inventory.fwd().insert(jochen, stick);

println!("Russell's items: {:?}", inventory.fwd().get(russell)); 
    // => beetle, pokemon_card
println!("Jochen's items: {:?}", inventory.fwd().get(jochen));  
    // => pizza, stick

moogle 还解决了其他一些问题：所有对 moogle 数据结构的操作都是确定性的，尽管它们支持共享，但 moogle 数据结构不允许你创建让 RefCell 发生恐慌的条件。

盒子里有什么？

moogle 提供了八个数据结构。每个都代表可能在关系数据库中看到的不同表格类型，每个都提供了自然的类型安全 Rust 接口。

基本数据结构是 Pom，一种表格类型。 Pom 是一个容器，其唯一目的是存储东西——向 Pom 添加某物会为其分配一个 Id（一个不透明的整数值），你可以使用它再次检索。

这些 Id 值满足 IdLike 特性，这是大多数其他 moogle 数据结构所必需的。它们的顺序是，新的元素具有更大的 Id。

此外，moogle 还提供了三种熟悉数据结构的表格表示

• ToOne 和 ToMany：类似于 Map<K, V> 和 Map<K, Set<V>> 的单向映射类型
• Set：类似于 BTreeSet<K> 的泛型有序集合类型

>>> xs = {1: "a", 2: "b"}
>>> for x, y in xs.items():
...   xs[3] = "c"
...   print(x, y)
...
1 a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration

>>> xs = {1: "scarf", 2: "ghost", "beware the": []}
>>> for x, y in xs.items():
...   if x in [1, 2]:
...     xs["beware the"].append(y)
...   else:
...     print(x, y)
...
beware the ['scarf', 'ghost']

    let letters: OneToMany<Alphabet, char> = OneToMany::new();
    letters.fwd().insert(english, 'a');
    letters.fwd().insert(english, 'b');
    letters.fwd().insert(english, 'd');
    letters.fwd().insert(english, 'e');

    let asc = letters.fwd().items();

    asc.next();  // (english, 'a')
    asc.next();  // (english, 'b')
    asc.next();  // (english, 'd')
    letters.fwd().insert(english, 'c');

    // don't see the 'c', we already passed it
    asc.next();  // (english, 'e')
    asc.next();  // None

    let possessions: OneToMany<Ghost, Item> = OneToMany::new();
    let sylvian_possessions = possessions.fwd().get(sylvian);
    println!("{:?}", sylvian_possessions);  // nothing
    possessions.fwd().insert(sylvian, plush)
    println!("{:?}", sylvian_possessions);  // {plush}
    sylvian_possessions.insert(fangs);
    possessions.iter(); // {(sylvian, plush), (sylvian, fangs)}

    let letters: OneToMany<Alphabet, char> = OneToMany::new();
    let english_letters = letters.fwd().get(english);
    letters.fwd().insert(english, 'a');
    letters.fwd().insert(english, 'b'):
    letters.fwd().insert(english, 'c');
    letters.fwd().insert(english, 'd');

    let desc = english_letters.items().rev();

    desc.next();  // 'd'
    desc.next();  // 'c'
    desc.next();  // 'b'
    letters.fwd().insert(english, 'f')

    // don't see the 'f', we already passed it
    desc.next();  // 'a'
    desc.next();  // None