To prevent the kind of memory errors that plagues many C programs, the borrow checker in Rust tracks how data is moved between variables, or accessed via references. This is all done at compile time, with zero runtime overhead, and is a sizeable part of Rust’s value offering.

Like all rigid and automated systems, however, it is necessarily constrained and cannot handle all situations perfectly. One of its limitations is treating all objects as atomic. It’s impossible for a variable to own a part of some bigger structure, neither is it possible to maintain mutable references to two or more elements of a collection.

If we nonetheless try:

fn get_name () -> String { let names = vec ! [ "John" . to_owned (), "Smith" . to_owned ()]; join ( names [ 0 ], names [ 1 ]) } fn join ( a : String , b : String ) -> String { a + " " + & b }

we’ll be served with a classic borrow checker error:

<anon>:3:25: 3:33 error: cannot move out of indexed content [E0507] <anon>:3 let fullname = join(names[0], names[1]); ^~~~~~~~

Behind its rather cryptic verbiage, it informs us that we tried to move a part of the names vector — its first element — to a new variable (here, a function parameter). This isn’t allowed, because in principle it would render the vector invalid from the standpoint of strict memory safety. Rust would no longer guarantee names[0] to be a legal String : its internal pointer could’ve been invalidated by the code which the element moved to (the join function).

But while commendable, this guarantee isn’t exactly useful here. Even though names[0] would technically be invalid, there isn’t anyone to actually notice this fact. The names vector is inaccessible outside of the function it’s defined in, and even the function itself doesn’t look at it after the move. In its present form, the program is inarguably correct could’ve been accepted if partial moves from Vec were allowed by the borrow checker.

Pointers to the rescue?

Vectors wouldn’t be very useful or efficient, though, if we could only obtain copies or clones of their elements. As this is an inherent limitation of Rust’s memory model, and applies to all compound types (structs, hashmaps, etc.), it’s been recognized and countermeasures are available.

However, the idiomatic practice is to actually leave the elements be and access them solely through references:

fn get_name () -> String { let names = vec ! [ "John" . to_owned (), "Smith" . to_owned ()]; join ( & names [ 0 ], & names [ 1 ]) } fn join ( a : & String , b : & String ) -> String { a . clone () + " " + b }

The obvious downside of this approach is that it requires an interface change to join : it now has to accept pointers instead of actual objects. And since the result is a completely new String , we have to either bite the bullet and clone , or write a more awkward join_into(a: &mut String, b: &String) function.

In general, making an API switch from actual objects to references has an annoying tendency to percolate up the call stacks and abstraction layers.

Vector solution

If we still insist on moving the elements out, at least in case of vector we aren’t completely out of luck. The Vec type offers several specialized methods that can slice, dice, and splice the collection in various ways. Those include:

split_first (and split_first_mut ) for cutting right after the first element

(and ) for cutting right after the first element split_last (and split_last_mut ) for a similar cut right before the last element

(and ) for a similar cut right before the last element split_at (and split_at_mut ), generalized versions of the above methods

(and ), generalized versions of the above methods split_off , a partially-in-place version of split_at_mut

, a partially-in-place version of drain for moving all elements from a specified range

Other types may offer different methods, depending on their particular data layout, though drain should be available on any data structure that can be iterated over.

Structural advantage

What about user-defined types, such as struct s?

Fortunately, these are covered by the compiler itself. Since accessing struct fields is a fully compile-time operation, it is possible to track the ownership of each individual object that makes up the structure. Thus there are no obstacles to simply moving all the fields:

struct Person { first_name : String , last_name : String , } fn get_name () -> String { let p = Person { first_name : "John" . to_owned (), last_name : "Smith" . to_owned ()}; join ( p . first_name , p . last_name ) }

If all else fails…

This leaves us with some rare cases when the container’s interface doesn’t quite support the exact subset of elements we want to move out. If we don’t want to drain them all and inspect every item for potential preservation, it may be time to skirt around the more dangerous areas of the language.

But I don’t necessarily mean going all out with unsafe blocks, pointers, and (let’s be honest) segfaults. Instead, we can look at the gray zone between them and the regular, borrow-checked Rust code.

Some of the functions inside the std::mem module can be said to fall into this category. Most notably, mem::swap and mem::replace allow us to operate directly on the memory blocks that back every Rust object, albeit without the dangerous ability to freely modify them.

What those functions enable is a small sleight of hand — a quick exchange of two variables or objects while the borrow checker “isn’t looking”. Possessing such an ability, we can smuggle any item out of a container as long as we’re able to provide a suitable replacement:

use std :: mem ; /// Pick only the items under indices that are powers of two. fn pick_powers_of_2 < T : Default > ( mut v : Vec < T > ) -> Vec < T > { let mut result : Vec < T > = Vec :: new (); let mut i = 1 ; while i < v . len () { let elem = mem :: replace ( & mut v [ i ], T :: default ()); result . push ( elem ); i *= 2 ; } result }

Pictured: implementation of mem::replace .