Esta pregunta está mal nombrada, pero básicamente, considere este ejemplo simplista:

Tiene una lista vinculada en el formulario:

struct Node<T> {
    _next: Option<~Node<T>>,
    _data: Option<T>
}

Y una operación 'push' que agrega elementos a la cadena:

/** Attach a node as the 'next' node in this chain */
fn push<'a>(&'a mut self, value: T) -> &'a mut ~Node<T> {
    if (self._next.is_none()) {
        self._push_node(~Node::new(value));
    } else {
        let tmp = self._next.take().unwrap();
        let mut next = ~Node::new(value);
        next._push_node(tmp);
        self._push_node(next);
    }
    return self._next.as_mut().unwrap();
}

Esto funciona, pero parece que sería más ordenado como una expresión match () en lugar de una declaración if, algo así como:

/** Attach a node as the 'next' node in this chain */
fn push<'a>(&'a mut self, value: T) -> &'a mut ~Node<T> {
    match self._next {
        None => { self._push_node(~Node::new(value)); },
        Some(ref v)  => { <----------------------------- :(
            let tmp = self._next.take().unwrap(); <------- ???
            let mut next = ~Node::new(value);
            next._push_node(tmp);
            self._push_node(next);
        }
    }
    return self._next.as_mut().unwrap();
}

Sin embargo, esto no funcionará debido a la línea indicada anteriormente; efectivamente, estamos modificando el valor de _next, lo que no puede suceder porque tomamos prestado self._next para el alcance de Some () de la declaración de coincidencia.

¿Hay una mejor manera de hacer esto?

¿Puede declarar de alguna manera una declaración de coincidencia puramente como una coincidencia, de modo que una vez que esté dentro del bloque Some () => {...} esténo pedir prestado el valor?