---

yaml
---
r: 152655
b: refs/heads/try2
c: 4c0f8f4
h: refs/heads/master
i:
  152653: eb36a99
  152651: 37eaee3
  152647: 9802e87
  152639: 714cf90
v: v3

Author: brendanzab

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: b84d17d4d77b04e1b7784d95e0c3cb2dca16f344
+refs/heads/try2: 4c0f8f49f6fe860efa268efa2f4fa0b5f00a4b07
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/mem.rs

@@ -403,10 +403,8 @@ pub fn from_be32(x: u32) -> u32 { ByteOrder::from_big_endian(x) }
 #[stable]
 pub fn from_be64(x: u64) -> u64 { ByteOrder::from_big_endian(x) }
 
-/**
- * Swap the values at two mutable locations of the same type, without
- * deinitialising or copying either one.
- */
+/// Swap the values at two mutable locations of the same type, without
+/// deinitialising or copying either one.
 #[inline]
 #[stable]
 pub fn swap<T>(x: &mut T, y: &mut T) {
@@ -425,42 +423,40 @@ 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())
- *     }
- * }
- * ```
- */
+/// 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]
 #[stable]
 pub fn replace<T>(dest: &mut T, mut src: T) -> T {