From 1be93e61da4cd63840a0b5318785547a009e8cae Mon Sep 17 00:00:00 2001
From: Kang Seonghoon <public+git@mearie.org>
Date: Sun, 27 Apr 2014 22:37:11 +0900
Subject: [PATCH] std: Add more docs to `std::mem::replace`.

---
 src/libstd/mem.rs | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs
index 342e565572b..d216d91b901 100644
--- a/src/libstd/mem.rs
+++ b/src/libstd/mem.rs
@@ -248,6 +248,38 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
 /**
  * Replace the value at a mutable location with a new one, returning the old
  * value, without deinitialising or copying either one.
+ *
+ * This is primarily used for transferring and swapping ownership of a value
+ * in a mutable location. For example, this function allows consumption of
+ * one field of a struct by replacing it with another value. The normal approach
+ * doesn't always work:
+ *
+ * ```rust,ignore
+ * struct Buffer<T> { buf: Vec<T> }
+ *
+ * impl<T> Buffer<T> {
+ *     fn get_and_reset(&mut self) -> Vec<T> {
+ *         // error: cannot move out of dereference of `&mut`-pointer
+ *         let buf = self.buf;
+ *         self.buf = Vec::new();
+ *         buf
+ *     }
+ * }
+ * ```
+ *
+ * Note that `T` does not necessarily implement `Clone`, so it can't even
+ * clone and reset `self.buf`. But `replace` can be used to disassociate
+ * the original value of `self.buf` from `self`, allowing it to be returned:
+ *
+ * ```rust
+ * # struct Buffer<T> { buf: Vec<T> }
+ * impl<T> Buffer<T> {
+ *     fn get_and_reset(&mut self) -> Vec<T> {
+ *         use std::mem::replace;
+ *         replace(&mut self.buf, Vec::new())
+ *     }
+ * }
+ * ```
  */
 #[inline]
 pub fn replace<T>(dest: &mut T, mut src: T) -> T {