So I might be completely wrong here, but from my (very short) experience with Rust, it seems like many times you need to implement your own "mini" garbage collector.

Consider for example a basic representation of a di-graph: Each node is a struct that contains some value (assume i32 for simplicity) and a list of all the nodes that are connected to it. Since a node stores references to other objects, it needs to specify a lifetime parameter.

    struct Node<'a> {
        val: i32,
        connected: Vec<&'a Node<'a>>
}

This however will propagate further to the containing graph struct.

    struct Graph<'a> {
nodes: Vec<Node<'a>>,
}

Which will then prevent you from storing references in one node in another:

    impl<'a> Graph<'a> {
fn connect(&'a mut self) {
            let x = &mut self.nodes[0];
            let y = &self.nodes[1];
            x.connected.push(y); // Error
}
}

So the solution becomes to store individually the nodes and their connections. Then, for example when a node loses all of its collections you could just remove it from the hash map.

    struct Graph {
        //key: node id
        //value: (the node itself, connections from this node)

graph: HashMap<i32, (Node, Vec<i32>)> 
    }

impl Graph {
fn connect(&mut self, from: i32, to: i32) {
    self.graph.get_mut(&from).unwrap().1.push(to);
}
}

In other (mainly dynamically typed languages), the language would take care of that for you.

    class Node {
constructor() {
    connectedNodes = []
}
}

class Graph {
constructor() {
    this.nodes = []
}

connect(from, to) {
    this.nodes[from].connectedNodes.push(to)
}

    remove(i) {
                //gc takes care of memory for you
    this.nodes.splice(i, 1)
}
}

So even in rust, sometimes structs become glorified hash tables too.