你也可以为枚举推导出 IntoHeap，但支持不完整：不会为枚举生成 Ref 类型。不支持元组结构体。

理解堆

这部分尚未很好地记录。但这里有一个例子，使用上面的 IntList

# extern crate cell_gc;
# #[macro_use] extern crate cell_gc_derive;
# #[derive(IntoHeap)]
# struct IntList<'h> {
#     head: i64,
#     tail: Option<IntListRef<'h>>
# }
use cell_gc::Heap;

fn main() {
    // Create a heap (you'll only do this once in your whole program)
    let mut heap = Heap::new();

    heap.enter(|hs| {
        // Allocate an object (returns an IntListRef)
        let obj1 = hs.alloc(IntList { head: 17, tail: None });
        assert_eq!(obj1.head(), 17);
        assert_eq!(obj1.tail(), None);

        // Allocate another object
        let obj2 = hs.alloc(IntList { head: 33, tail: Some(obj1) });
        assert_eq!(obj2.head(), 33);
        assert_eq!(obj2.tail().unwrap().head(), 17);
    });
}

在您的 main() 函数中使用 Heap::new() 来创建一个堆。使用 heap.enter() 来访问堆（打开一个“堆会话”，hs）。使用 hs.alloc(v) 在堆中分配值。

GC堆中的向量

一个用于文字冒险游戏的非常简单的“对象”类型

extern crate cell_gc;
#[macro_use] extern crate cell_gc_derive;

use cell_gc::collections::VecRef;

#[derive(IntoHeap)]
struct Object<'h> {
    name: String,
    description: String,
    children: VecRef<'h, ObjectRef<'h>>
}
# fn main() {}

注意，children 是一个 VecRef<'h, ObjectRef<'h>>；也就是说，它是对一个单独GC分配的 Vec<ObjectRef<'h>> 的引用，这是一个指向其他对象的引用的向量。换句话说，这正好是你希望在Java中使用此声明的字段时会有什么

public ArrayList<Object> children;

由这个宏生成的API看起来像这样

# struct VecRef<'h, T: 'h>(&'h T);  // hack to make this compile
struct Object<'h> {
    name: String,
    description: String,
    children: VecRef<'h, ObjectRef<'h>>
}

struct ObjectRef<'h> {
   /* all fields private */
#  target: &'h Object<'h>     // hack to make this compile
}

impl<'h> ObjectRef<'h> {
    fn name(&self) -> String
#       { unimplemented!(); }
    fn set_name(&self, name: String)
#       { unimplemented!(); }
    fn description(&self) -> String
#       { unimplemented!(); }
    fn set_description(&self, description: String)
#       { unimplemented!(); }
    fn children(&self) -> VecRef<'h, ObjectRef<'h>>
#       { unimplemented!(); }
    fn set_children(&self, children: VecRef<'h, ObjectRef<'h>>)
#       { unimplemented!(); }
}

（您可能永远不会真正使用那个 set_children() 方法。相反，您将在创建对象时用向量初始化 children 字段，然后您很可能将现有的向量进行修改而不是创建一个新的。）

您可以使用 hs.alloc(Object { ... }) 在堆中分配 Object，并通过使用 obj1.children().push(obj2) 将一个 Object 设为另一个的子对象。

安全性

只要您在代码中不键入关键字 unsafe，这个GC就是安全的。^{[需要引用]}

尽管如此，还有一个需要注意的奇怪规则：不要为使用 derive(IntoHeap) 声明的任何类型实现 Drop 或 Clone。 在Rust的全意义上这个词是安全的（它不会导致崩溃或未定义的行为，只要你的 .drop() 或 .clone() 方法不执行 unsafe），但它不会按预期工作。您的 .drop() 和 .clone() 方法将不会在您期望的时候被调用；它们会在其他没有意义的时候被调用。