auto merge of #9475 : alexcrichton/rust/rustdoc++, r=cmr

The commit messages are a good technical summary, a good visual summary (contrib is this version):

Pub use statements now rendered. Notice how almost all components are also clickable!
* http://static.rust-lang.org/doc/master/std/prelude/index.html
* http://www.contrib.andrew.cmu.edu/~acrichto/doc/std/prelude/index.html

Private things hidden by default (for at least some approximation of privacy). I hope to improve this once privacy is totally ironed out.
* http://static.rust-lang.org/doc/master/std/hashmap/struct.HashMap.html
* http://www.contrib.andrew.cmu.edu/~acrichto/doc/std/hashmap/struct.HashMap.html

Unindentation now works properly:
* http://static.rust-lang.org/doc/master/extra/getopts/index.html
* http://www.contrib.andrew.cmu.edu/~acrichto/doc/extra/getopts/index.html

Also sundown has massively reduced compilation time (of docs, not the of the crates)

25 files changed, 300 insertions, 301 deletions

diff --git a/src/libstd/bool.rs b/src/libstd/bool.rs
index 4ef50094139..1d59e63e702 100644
--- a/src/libstd/bool.rs
+++ b/src/libstd/bool.rs
@@ -52,15 +52,15 @@ use to_str::ToStr;
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::not(true)
 * false
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::not(false)
 * true
-* ~~~
+* ```
 */
 pub fn not(v: bool) -> bool { !v }
 
@@ -69,15 +69,15 @@ pub fn not(v: bool) -> bool { !v }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::and(true, false)
 * false
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::and(true, true)
 * true
-* ~~~
+* ```
 */
 pub fn and(a: bool, b: bool) -> bool { a && b }
 
@@ -86,15 +86,15 @@ pub fn and(a: bool, b: bool) -> bool { a && b }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::or(true, false)
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::or(false, false)
 * false
-* ~~~
+* ```
 */
 pub fn or(a: bool, b: bool) -> bool { a || b }
 
@@ -105,15 +105,15 @@ pub fn or(a: bool, b: bool) -> bool { a || b }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::xor(true, false)
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::xor(true, true)
 * false
-* ~~~
+* ```
 */
 pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 
@@ -126,15 +126,15 @@ pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::implies(true, true)
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::implies(true, false)
 * false
-* ~~~
+* ```
 */
 pub fn implies(a: bool, b: bool) -> bool { !a || b }
 
@@ -143,15 +143,15 @@ pub fn implies(a: bool, b: bool) -> bool { !a || b }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::is_true(true)
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::is_true(false)
 * false
-* ~~~
+* ```
 */
 pub fn is_true(v: bool) -> bool { v }
 
@@ -160,15 +160,15 @@ pub fn is_true(v: bool) -> bool { v }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::is_false(false)
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::is_false(true)
 * false
-* ~~~
+* ```
 */
 pub fn is_false(v: bool) -> bool { !v }
 
@@ -179,20 +179,20 @@ pub fn is_false(v: bool) -> bool { !v }
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> FromStr::from_str::<bool>("true")
 * Some(true)
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> FromStr::from_str::<bool>("false")
 * Some(false)
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> FromStr::from_str::<bool>("not even a boolean")
 * None
-* ~~~
+* ```
 */
 impl FromStr for bool {
     fn from_str(s: &str) -> Option<bool> {
@@ -209,15 +209,15 @@ impl FromStr for bool {
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> true.to_str()
 * "true"
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> false.to_str()
 * "false"
-* ~~~
+* ```
 */
 impl ToStr for bool {
     #[inline]
@@ -232,11 +232,11 @@ impl ToStr for bool {
 * There are no guarantees about the order values will be given.
 *
 * # Examples
-* ~~~
+* ```
 * do std::bool::all_values |x: bool| {
 *     println(x.to_str())
 * }
-* ~~~
+* ```
 */
 pub fn all_values(blk: &fn(v: bool)) {
     blk(true);
@@ -248,15 +248,15 @@ pub fn all_values(blk: &fn(v: bool)) {
 *
 * # Examples
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::to_bit(true)
 * 1
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> std::bool::to_bit(false)
 * 0
-* ~~~
+* ```
 */
 #[inline]
 pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
@@ -269,12 +269,12 @@ pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 * ~~~rust
 * rusti> !true
 * false
-* ~~~
+* ```
 *
 * ~~~rust
 * rusti> !false
 * true
-* ~~~
+* ```
 */
 #[cfg(not(test))]
 impl Not<bool> for bool {
@@ -299,25 +299,25 @@ impl TotalOrd for bool {
 *
 * Two booleans are equal if they have the same value.
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> false.eq(&true)
 * false
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> false == false
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> false != true
 * true
-* ~~~
+* ```
 *
-* ~~~ {.rust}
+* ```rust
 * rusti> false.ne(&false)
 * false
-* ~~~
+* ```
 */
 #[cfg(not(test))]
 impl Eq for bool {
diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index 3c50ff35358..823cc0db4b9 100644
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -38,7 +38,7 @@ unnecessary amounts of allocations.
 
 An example of creating and using a C string would be:
 
-~~~{.rust}
+```rust
 use std::libc;
 externfn!(fn puts(s: *libc::c_char))
 
@@ -56,7 +56,7 @@ do my_c_string.with_ref |c_buffer| {
 do my_string.with_c_str |c_buffer| {
     unsafe { puts(c_buffer); }
 }
-~~~
+ ```
 
 */
 
@@ -204,9 +204,9 @@ pub trait ToCStr {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let s = "PATH".with_c_str(|path| libc::getenv(path))
-    /// ~~~
+    /// ```
     ///
     /// # Failure
     ///
diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs
index a4e18d98f47..e028bbeac68 100644
--- a/src/libstd/cast.rs
+++ b/src/libstd/cast.rs
@@ -67,10 +67,10 @@ pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
  *
  * # Example
  *
- * ~~~ {.rust}
+ * ```rust
  * let v: &[u8] = transmute("L");
  * assert!(v == [76u8]);
- * ~~~
+ * ```
  */
 #[inline]
 pub unsafe fn transmute<L, G>(thing: L) -> G {
diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs
index c47dcfe3de6..39db1df3df1 100644
--- a/src/libstd/condition.rs
+++ b/src/libstd/condition.rs
@@ -19,17 +19,17 @@ same manner.
 
 A condition is declared through the `condition!` macro provided by the compiler:
 
-~~~{.rust}
+```rust
 condition! {
     pub my_error: int -> ~str;
 }
-~~~
+ ```
 
 This macro declares an inner module called `my_error` with one static variable,
 `cond` that is a static `Condition` instance. To help understand what the other
 parameters are used for, an example usage of this condition would be:
 
-~~~{.rust}
+```rust
 do my_error::cond.trap(|raised_int| {
 
     // the condition `my_error` was raised on, and the value it raised is stored
@@ -51,7 +51,7 @@ do my_error::cond.trap(|raised_int| {
     println(my_error::cond.raise(4)); // prints "oh well"
 
 }
-~~~
+ ```
 
 Condition handling is useful in cases where propagating errors is either to
 cumbersome or just not necessary in the first place. It should also be noted,
@@ -96,14 +96,14 @@ impl<T, U> Condition<T, U> {
     ///
     /// # Example
     ///
-    /// ~~~{.rust}
+    /// ```rust
     /// condition! { my_error: int -> int; }
     ///
     /// let trap = my_error::cond.trap(|error| error + 3);
     ///
     /// // use `trap`'s inside method to register the handler and then run a
     /// // block of code with the handler registered
-    /// ~~~
+    /// ```
     pub fn trap<'a>(&'a self, h: &'a fn(T) -> U) -> Trap<'a, T, U> {
         let h: Closure = unsafe { ::cast::transmute(h) };
         let prev = local_data::get(self.key, |k| k.map(|&x| *x));
@@ -173,14 +173,14 @@ impl<'self, T, U> Trap<'self, T, U> {
     ///
     /// # Example
     ///
-    /// ~~~{.rust}
+    /// ```rust
     /// condition! { my_error: int -> int; }
     ///
     /// let result = do my_error::cond.trap(|error| error + 3).inside {
     ///     my_error::cond.raise(4)
     /// };
     /// assert_eq!(result, 7);
-    /// ~~~
+    /// ```
     pub fn inside<V>(&self, inner: &'self fn() -> V) -> V {
         let _g = Guard { cond: self.cond };
         debug!("Trap: pushing handler to TLS");
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index 99a5ed4d698..f35a61677e8 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -33,14 +33,14 @@ arguments directly while performing minimal allocations.
 
 Some examples of the `format!` extension are:
 
-~~~{.rust}
+```rust
 format!("Hello")                  // => ~"Hello"
 format!("Hello, {:s}!", "world")  // => ~"Hello, world!"
 format!("The number is {:d}", 1)  // => ~"The number is 1"
 format!("{:?}", ~[3, 4])          // => ~"~[3, 4]"
 format!("{value}", value=4)       // => ~"4"
 format!("{} {}", 1, 2)            // => ~"1 2"
-~~~
+ ```
 
 From these, you can see that the first argument is a format string. It is
 required by the compiler for this to be a string literal; it cannot be a
@@ -67,9 +67,9 @@ function, but the `format!` macro is a syntax extension which allows it to
 leverage named parameters. Named parameters are listed at the end of the
 argument list and have the syntax:
 
-~~~
+ ```
 identifier '=' expression
-~~~
+ ```
 
 It is illegal to put positional parameters (those without names) after arguments
 which have names. Like positional parameters, it is illegal to provided named
@@ -84,9 +84,9 @@ and if all references to one argument do not provide a type, then the format `?`
 is used (the type's rust-representation is printed). For example, this is an
 invalid format string:
 
-~~~
+ ```
 {0:d} {0:s}
-~~~
+ ```
 
 Because the first argument is both referred to as an integer as well as a
 string.
@@ -100,9 +100,9 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
 illegal to reference an argument as such. For example, this is another invalid
 format string:
 
-~~~
+ ```
 {:.*s} {0:u}
-~~~
+ ```
 
 ### Formatting traits
 
@@ -134,9 +134,9 @@ is `?` which is defined for all types by default.
 When implementing a format trait for your own time, you will have to implement a
 method of the signature:
 
-~~~{.rust}
+```rust
 fn fmt(value: &T, f: &mut std::fmt::Formatter);
-~~~
+ ```
 
 Your type will be passed by-reference in `value`, and then the function should
 emit output into the `f.buf` stream. It is up to each format trait
@@ -150,14 +150,14 @@ helper methods.
 There are a number of related macros in the `format!` family. The ones that are
 currently implemented are:
 
-~~~{.rust}
+```rust
 format!      // described above
 write!       // first argument is a &mut rt::io::Writer, the destination
 writeln!     // same as write but appends a newline
 print!       // the format string is printed to the standard output
 println!     // same as print but appends a newline
 format_args! // described below.
-~~~
+ ```
 
 
 #### `write!`
@@ -167,12 +167,12 @@ specified stream. This is used to prevent intermediate allocations of format
 strings and instead directly write the output. Under the hood, this function is
 actually invoking the `write` function defined in this module. Example usage is:
 
-~~~{.rust}
+```rust
 use std::rt::io;
 
 let mut w = io::mem::MemWriter::new();
 write!(&mut w as &mut io::Writer, "Hello {}!", "world");
-~~~
+ ```
 
 #### `print!`
 
@@ -180,10 +180,10 @@ This and `println` emit their output to stdout. Similarly to the `write!` macro,
 the goal of these macros is to avoid intermediate allocations when printing
 output. Example usage is:
 
-~~~{.rust}
+```rust
 print!("Hello {}!", "world");
 println!("I have a newline {}", "character at the end");
-~~~
+ ```
 
 #### `format_args!`
 This is a curious macro which is used to safely pass around
@@ -193,13 +193,13 @@ references information on the stack. Under the hood, all of
 the related macros are implemented in terms of this. First
 off, some example usage is:
 
-~~~{.rust}
+```rust
 use std::fmt;
 
 format_args!(fmt::format, "this returns {}", "~str");
 format_args!(|args| { fmt::write(my_writer, args) }, "some {}", "args");
 format_args!(my_fn, "format {}", "string");
-~~~
+ ```
 
 The first argument of the `format_args!` macro is a function (or closure) which
 takes one argument of type `&fmt::Arguments`. This structure can then be
@@ -236,9 +236,9 @@ Furthermore, whenever a case is running, the special character `#` can be used
 to reference the string value of the argument which was selected upon. As an
 example:
 
-~~~{.rust}
+```rust
 format!("{0, select, other{#}}", "hello") // => ~"hello"
-~~~
+ ```
 
 This example is the equivalent of `{0:s}` essentially.
 
@@ -247,9 +247,9 @@ This example is the equivalent of `{0:s}` essentially.
 The select method is a switch over a `&str` parameter, and the parameter *must*
 be of the type `&str`. An example of the syntax is:
 
-~~~
+ ```
 {0, select, male{...} female{...} other{...}}
-~~~
+ ```
 
 Breaking this down, the `0`-th argument is selected upon with the `select`
 method, and then a number of cases follow. Each case is preceded by an
@@ -266,9 +266,9 @@ The plural method is a switch statement over a `uint` parameter, and the
 parameter *must* be a `uint`. A plural method in its full glory can be specified
 as:
 
-~~~
+ ```
 {0, plural, offset=1 =1{...} two{...} many{...} other{...}}
-~~~
+ ```
 
 To break this down, the first `0` indicates that this method is selecting over
 the value of the first positional parameter to the format string. Next, the
@@ -294,7 +294,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
 meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
 actual grammar for the formatting syntax is:
 
-~~~
+ ```
 format_string := <text> [ format <text> ] *
 format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
 argument := integer | identifier
@@ -315,7 +315,7 @@ plural := 'plural' ',' [ 'offset:' integer ] ( selector arm ) *
 selector := '=' integer | keyword
 keyword := 'zero' | 'one' | 'two' | 'few' | 'many' | 'other'
 arm := '{' format_string '}'
-~~~
+ ```
 
 ## Formatting Parameters
 
@@ -516,11 +516,11 @@ pub trait Float { fn fmt(&Self, &mut Formatter); }
 ///
 /// # Example
 ///
-/// ~~~{.rust}
+/// ```rust
 /// use std::fmt;
 /// let w: &mut io::Writer = ...;
 /// format_args!(|args| { fmt::write(w, args) }, "Hello, {}!", "world");
-/// ~~~
+/// ```
 pub fn write(output: &mut io::Writer, args: &Arguments) {
     unsafe { write_unsafe(output, args.fmt, args.args) }
 }
@@ -581,11 +581,11 @@ pub unsafe fn write_unsafe(output: &mut io::Writer,
 ///
 /// # Example
 ///
-/// ~~~{.rust}
+/// ```rust
 /// use std::fmt;
 /// let s = format_args!(fmt::format, "Hello, {}!", "world");
 /// assert_eq!(s, "Hello, world!");
-/// ~~~
+/// ```
 pub fn format(args: &Arguments) -> ~str {
     unsafe { format_unsafe(args.fmt, args.args) }
 }
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index ab8af22e116..859cf20fa41 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -1047,11 +1047,11 @@ pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
 *
 * # Example
 *
-* ~~~ {.rust}
+* ```rust
 * let stdin = std::io::stdin();
 * let line = stdin.read_line();
 * std::io::print(line);
-* ~~~
+* ```
 */
 pub fn stdin() -> @Reader {
     #[fixed_stack_segment]; #[inline(never)];
@@ -1650,10 +1650,10 @@ pub fn buffered_file_writer(path: &Path) -> Result<@Writer, ~str> {
 *
 * # Example
 *
-* ~~~ {.rust}
+* ```rust
 * let stdout = std::io::stdout();
 * stdout.write_str("hello\n");
-* ~~~
+* ```
 */
 pub fn stdout() -> @Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) }
 
@@ -1662,10 +1662,10 @@ pub fn stdout() -> @Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) }
 *
 * # Example
 *
-* ~~~ {.rust}
+* ```rust
 * let stderr = std::io::stderr();
 * stderr.write_str("hello\n");
-* ~~~
+* ```
 */
 pub fn stderr() -> @Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
 
@@ -1677,10 +1677,10 @@ pub fn stderr() -> @Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
 *
 * # Example
 *
-* ~~~ {.rust}
+* ```rust
 * // print is imported into the prelude, and so is always available.
 * print("hello");
-* ~~~
+* ```
 */
 pub fn print(s: &str) {
     stdout().write_str(s);
@@ -1693,10 +1693,10 @@ pub fn print(s: &str) {
 *
 * # Example
 *
-* ~~~ {.rust}
+* ```rust
 * // println is imported into the prelude, and so is always available.
 * println("hello");
-* ~~~
+* ```
 */
 pub fn println(s: &str) {
     stdout().write_line(s);
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 87fad9aae70..0e4cb895249 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -34,7 +34,7 @@ trait defined in this module. For loops can be viewed as a syntactical expansion
 into a `loop`, for example, the `for` loop in this example is essentially
 translated to the `loop` below.
 
-~~~{.rust}
+```rust
 let values = ~[1, 2, 3];
 
 // "Syntactical sugar" taking advantage of an iterator
@@ -52,7 +52,7 @@ loop {
         None => { break }
     }
 }
-~~~
+ ```
 
 This `for` loop syntax can be applied to any iterator over any type.
 
@@ -111,14 +111,14 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [0];
     /// let b = [1];
     /// let mut it = a.iter().chain(b.iter());
     /// assert_eq!(it.next().get(), &0);
     /// assert_eq!(it.next().get(), &1);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn chain<U: Iterator<A>>(self, other: U) -> Chain<Self, U> {
         Chain{a: self, b: other, flag: false}
@@ -131,13 +131,13 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [0];
     /// let b = [1];
     /// let mut it = a.iter().zip(b.iter());
     /// assert_eq!(it.next().get(), (&0, &1));
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn zip<B, U: Iterator<B>>(self, other: U) -> Zip<Self, U> {
         Zip{a: self, b: other}
@@ -148,13 +148,13 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2];
     /// let mut it = a.iter().map(|&x| 2 * x);
     /// assert_eq!(it.next().get(), 2);
     /// assert_eq!(it.next().get(), 4);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn map<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, Self> {
         Map{iter: self, f: f}
@@ -166,12 +166,12 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2];
     /// let mut it = a.iter().filter(|&x| *x > 1);
     /// assert_eq!(it.next().get(), &2);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> Filter<'r, A, Self> {
         Filter{iter: self, predicate: predicate}
@@ -183,12 +183,12 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2];
     /// let mut it = a.iter().filter_map(|&x| if x > 1 {Some(2 * x)} else {None});
     /// assert_eq!(it.next().get(), 4);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn filter_map<'r, B>(self, f: &'r fn(A) -> Option<B>) -> FilterMap<'r, A, B, Self> {
         FilterMap { iter: self, f: f }
@@ -199,13 +199,13 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [100, 200];
     /// let mut it = a.iter().enumerate();
     /// assert_eq!(it.next().get(), (0, &100));
     /// assert_eq!(it.next().get(), (1, &200));
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn enumerate(self) -> Enumerate<Self> {
         Enumerate{iter: self, count: 0}
@@ -217,7 +217,7 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [100, 200, 300];
     /// let mut it = xs.iter().map(|&x|x).peekable();
     /// assert_eq!(it.peek().unwrap(), &100);
@@ -228,7 +228,7 @@ pub trait Iterator<A> {
     /// assert_eq!(it.next().unwrap(), 300);
     /// assert!(it.peek().is_none());
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn peekable(self) -> Peekable<A, Self> {
         Peekable{iter: self, peeked: None}
@@ -240,14 +240,14 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 2, 1];
     /// let mut it = a.iter().skip_while(|&a| *a < 3);
     /// assert_eq!(it.next().get(), &3);
     /// assert_eq!(it.next().get(), &2);
     /// assert_eq!(it.next().get(), &1);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhile<'r, A, Self> {
         SkipWhile{iter: self, flag: false, predicate: predicate}
@@ -259,13 +259,13 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 2, 1];
     /// let mut it = a.iter().take_while(|&a| *a < 3);
     /// assert_eq!(it.next().get(), &1);
     /// assert_eq!(it.next().get(), &2);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhile<'r, A, Self> {
         TakeWhile{iter: self, flag: false, predicate: predicate}
@@ -276,13 +276,13 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().skip(3);
     /// assert_eq!(it.next().get(), &4);
     /// assert_eq!(it.next().get(), &5);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn skip(self, n: uint) -> Skip<Self> {
         Skip{iter: self, n: n}
@@ -293,14 +293,14 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().take(3);
     /// assert_eq!(it.next().get(), &1);
     /// assert_eq!(it.next().get(), &2);
     /// assert_eq!(it.next().get(), &3);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn take(self, n: uint) -> Take<Self> {
         Take{iter: self, n: n}
@@ -313,7 +313,7 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().scan(1, |fac, &x| {
     ///   *fac = *fac * x;
@@ -325,7 +325,7 @@ pub trait Iterator<A> {
     /// assert_eq!(it.next().get(), 24);
     /// assert_eq!(it.next().get(), 120);
     /// assert!(it.next().is_none());
-    /// ~~~
+    /// ```
     #[inline]
     fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option<B>)
         -> Scan<'r, A, B, Self, St> {
@@ -337,7 +337,7 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let xs = [2u, 3];
     /// let ys = [0u, 1, 0, 1, 2];
     /// let mut it = xs.iter().flat_map(|&x| count(0u, 1).take(x));
@@ -347,7 +347,7 @@ pub trait Iterator<A> {
     ///     assert_eq!(x, ys[i]);
     ///     i += 1;
     /// }
-    /// ~~~
+    /// ```
     #[inline]
     fn flat_map<'r, B, U: Iterator<B>>(self, f: &'r fn(A) -> U)
         -> FlatMap<'r, A, Self, U> {
@@ -360,7 +360,7 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// fn process<U: Iterator<int>>(it: U) -> int {
     ///     let mut it = it.fuse();
     ///     let mut sum = 0;
@@ -378,7 +378,7 @@ pub trait Iterator<A> {
     /// }
     /// let x = ~[1,2,3,7,8,9];
     /// assert_eq!(process(x.move_iter()), 1006);
-    /// ~~~
+    /// ```
     #[inline]
     fn fuse(self) -> Fuse<Self> {
         Fuse{iter: self, done: false}
@@ -390,7 +390,7 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     ///let xs = [1u, 4, 2, 3, 8, 9, 6];
     ///let sum = xs.iter()
     ///            .map(|&x| x)
@@ -399,7 +399,7 @@ pub trait Iterator<A> {
     ///            .inspect(|&x| debug!("%u made it through", x))
     ///            .sum();
     ///println(sum.to_str());
-    /// ~~~
+    /// ```
     #[inline]
     fn inspect<'r>(self, f: &'r fn(&A)) -> Inspect<'r, A, Self> {
         Inspect{iter: self, f: f}
@@ -409,13 +409,13 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::iter::count;
     ///
     /// for i in count(0, 10) {
     ///     printfln!("%d", i);
     /// }
-    /// ~~~
+    /// ```
     #[inline]
     fn advance(&mut self, f: &fn(A) -> bool) -> bool {
         loop {
@@ -433,11 +433,11 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let b: ~[int] = a.iter().map(|&x| x).collect();
     /// assert!(a == b);
-    /// ~~~
+    /// ```
     #[inline]
     fn collect<B: FromIterator<A>>(&mut self) -> B {
         FromIterator::from_iterator(self)
@@ -448,11 +448,11 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let b: ~[int] = a.iter().map(|&x| x).to_owned_vec();
     /// assert!(a == b);
-    /// ~~~
+    /// ```
     #[inline]
     fn to_owned_vec(&mut self) -> ~[A] {
         self.collect()
@@ -463,12 +463,12 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
     /// assert!(it.nth(2).get() == &3);
     /// assert!(it.nth(2) == None);
-    /// ~~~
+    /// ```
     #[inline]
     fn nth(&mut self, mut n: uint) -> Option<A> {
         loop {
@@ -485,10 +485,10 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().last().get() == &5);
-    /// ~~~
+    /// ```
     #[inline]
     fn last(&mut self) -> Option<A> {
         let mut last = None;
@@ -501,10 +501,10 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().fold(0, |a, &b| a + b) == 15);
-    /// ~~~
+    /// ```
     #[inline]
     fn fold<B>(&mut self, init: B, f: &fn(B, A) -> B) -> B {
         let mut accum = init;
@@ -521,12 +521,12 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
     /// assert!(it.len() == 5);
     /// assert!(it.len() == 0);
-    /// ~~~
+    /// ```
     #[inline]
     fn len(&mut self) -> uint {
         self.fold(0, |cnt, _x| cnt + 1)
@@ -536,11 +536,11 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().all(|&x| *x > 0));
     /// assert!(!a.iter().all(|&x| *x > 2));
-    /// ~~~
+    /// ```
     #[inline]
     fn all(&mut self, f: &fn(A) -> bool) -> bool {
         for x in *self { if !f(x) { return false; } }
@@ -552,12 +552,12 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
     /// assert!(it.any(|&x| *x == 3));
     /// assert!(!it.any(|&x| *x == 3));
-    /// ~~~
+    /// ```
     #[inline]
     fn any(&mut self, f: &fn(A) -> bool) -> bool {
         for x in *self { if f(x) { return true; } }
@@ -601,10 +601,10 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let xs = [-3, 0, 1, 5, -10];
     /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
-    /// ~~~
+    /// ```
     #[inline]
     fn max_by<B: Ord>(&mut self, f: &fn(&A) -> B) -> Option<A> {
         self.fold(None, |max: Option<(A, B)>, x| {
@@ -625,10 +625,10 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let xs = [-3, 0, 1, 5, -10];
     /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
-    /// ~~~
+    /// ```
     #[inline]
     fn min_by<B: Ord>(&mut self, f: &fn(&A) -> B) -> Option<A> {
         self.fold(None, |min: Option<(A, B)>, x| {
@@ -777,11 +777,11 @@ pub trait AdditiveIterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().map(|&x| x);
     /// assert!(it.sum() == 15);
-    /// ~~~
+    /// ```
     fn sum(&mut self) -> A;
 }
 
@@ -800,7 +800,7 @@ pub trait MultiplicativeIterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::iter::count;
     ///
     /// fn factorial(n: uint) -> uint {
@@ -809,7 +809,7 @@ pub trait MultiplicativeIterator<A> {
     /// assert!(factorial(0) == 1);
     /// assert!(factorial(1) == 1);
     /// assert!(factorial(5) == 120);
-    /// ~~~
+    /// ```
     fn product(&mut self) -> A;
 }
 
@@ -828,20 +828,20 @@ pub trait OrdIterator<A> {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().max().get() == &5);
-    /// ~~~
+    /// ```
     fn max(&mut self) -> Option<A>;
 
     /// Consumes the entire iterator to return the minimum element.
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().min().get() == &1);
-    /// ~~~
+    /// ```
     fn min(&mut self) -> Option<A>;
 }
 
@@ -873,12 +873,12 @@ pub trait ClonableIterator {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let a = count(1,1).take(1);
     /// let mut cy = a.cycle();
     /// assert_eq!(cy.next(), Some(1));
     /// assert_eq!(cy.next(), Some(1));
-    /// ~~~
+    /// ```
     fn cycle(self) -> Cycle<Self>;
 }
 
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 9c4e5ba60df..5058821d456 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -22,7 +22,7 @@ To declare a new key for storing local data of a particular type, use the
 named and annotated. This name is then passed to the functions in this module to
 modify/read the slot specified by the key.
 
-~~~{.rust}
+```rust
 use std::local_data;
 
 local_data_key!(key_int: int)
@@ -33,7 +33,7 @@ local_data::get(key_int, |opt| assert_eq!(opt, Some(&3)));
 
 local_data::set(key_vector, ~[4]);
 local_data::get(key_vector, |opt| assert_eq!(opt, Some(&~[4])));
-~~~
+ ```
 
 */
 
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index a2a0a1ab13b..afa1acd0897 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -346,9 +346,9 @@ impl Round for f32 {
     ///
     /// The fractional part of the number, satisfying:
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// assert!(x == trunc(x) + fract(x))
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn fract(&self) -> f32 { *self - self.trunc() }
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index f7c31c40250..5dbeb6c298f 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -364,9 +364,9 @@ impl Round for f64 {
     ///
     /// The fractional part of the number, satisfying:
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// assert!(x == trunc(x) + fract(x))
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn fract(&self) -> f64 { *self - self.trunc() }
diff --git a/src/libstd/num/float.rs b/src/libstd/num/float.rs
index dc46d4fec32..7af47355c8c 100644
--- a/src/libstd/num/float.rs
+++ b/src/libstd/num/float.rs
@@ -414,9 +414,9 @@ impl Round for float {
     ///
     /// The fractional part of the number, satisfying:
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// assert!(x == trunc(x) + fract(x))
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn fract(&self) -> float { *self - self.trunc() }
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index ba8beeba4f6..1070e8e592f 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -118,7 +118,7 @@ impl Div<$T,$T> for $T {
     ///
     /// # Examples
     ///
-    /// ~~~
+    /// ```
     /// assert!( 8 /  3 ==  2);
     /// assert!( 8 / -3 == -2);
     /// assert!(-8 /  3 == -2);
@@ -128,7 +128,7 @@ impl Div<$T,$T> for $T {
     /// assert!( 1 / -2 ==  0);
     /// assert!(-1 /  2 ==  0);
     /// assert!(-1 / -2 ==  0);
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn div(&self, other: &$T) -> $T { *self / *other }
@@ -139,13 +139,13 @@ impl Rem<$T,$T> for $T {
     ///
     /// Returns the integer remainder after division, satisfying:
     ///
-    /// ~~~
+    /// ```
     /// assert!((n / d) * d + (n % d) == n)
-    /// ~~~
+    /// ```
     ///
     /// # Examples
     ///
-    /// ~~~
+    /// ```
     /// assert!( 8 %  3 ==  2);
     /// assert!( 8 % -3 ==  2);
     /// assert!(-8 %  3 == -2);
@@ -155,7 +155,7 @@ impl Rem<$T,$T> for $T {
     /// assert!( 1 % -2 ==  1);
     /// assert!(-1 %  2 == -1);
     /// assert!(-1 % -2 == -1);
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn rem(&self, other: &$T) -> $T { *self % *other }
@@ -214,7 +214,7 @@ impl Integer for $T {
     ///
     /// # Examples
     ///
-    /// ~~~
+    /// ```
     /// assert!(( 8).div_floor( 3) ==  2);
     /// assert!(( 8).div_floor(-3) == -3);
     /// assert!((-8).div_floor( 3) == -3);
@@ -224,7 +224,7 @@ impl Integer for $T {
     /// assert!(( 1).div_floor(-2) == -1);
     /// assert!((-1).div_floor( 2) == -1);
     /// assert!((-1).div_floor(-2) ==  0);
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn div_floor(&self, other: &$T) -> $T {
@@ -240,13 +240,13 @@ impl Integer for $T {
     ///
     /// Integer modulo, satisfying:
     ///
-    /// ~~~
+    /// ```
     /// assert!(n.div_floor(d) * d + n.mod_floor(d) == n)
-    /// ~~~
+    /// ```
     ///
     /// # Examples
     ///
-    /// ~~~
+    /// ```
     /// assert!(( 8).mod_floor( 3) ==  2);
     /// assert!(( 8).mod_floor(-3) == -1);
     /// assert!((-8).mod_floor( 3) ==  1);
@@ -256,7 +256,7 @@ impl Integer for $T {
     /// assert!(( 1).mod_floor(-2) == -1);
     /// assert!((-1).mod_floor( 2) ==  1);
     /// assert!((-1).mod_floor(-2) == -1);
-    /// ~~~
+    /// ```
     ///
     #[inline]
     fn mod_floor(&self, other: &$T) -> $T {
diff --git a/src/libstd/num/num.rs b/src/libstd/num/num.rs
index 634c86104fb..a60bf2f33a9 100644
--- a/src/libstd/num/num.rs
+++ b/src/libstd/num/num.rs
@@ -82,12 +82,12 @@ pub trait Unsigned: Num {}
 
 /// Times trait
 ///
-/// ~~~ {.rust}
+/// ```rust
 /// use num::Times;
 /// let ten = 10 as uint;
 /// let mut accum = 0;
 /// do ten.times { accum += 1; }
-/// ~~~
+/// ```
 ///
 pub trait Times {
     fn times(&self, it: &fn());
@@ -357,10 +357,10 @@ pub trait Float: Real
 ///
 /// # Example
 ///
-/// ~~~
+/// ```
 /// let twenty: f32 = num::cast(0x14);
 /// assert_eq!(twenty, 20f32);
-/// ~~~
+/// ```
 ///
 #[inline]
 pub fn cast<T:NumCast,U:NumCast>(n: T) -> U {
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 37c5807c70b..a8d4cf541ce 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -23,7 +23,7 @@ of a value and take action, always accounting for the `None` case.
 
 # Example
 
-~~~
+ ```
 let msg = Some(~"howdy");
 
 // Take a reference to the contained string
@@ -37,7 +37,7 @@ let unwrapped_msg = match msg {
     Some(m) => m,
     None => ~"default message"
 };
-~~~
+ ```
 
 */
 
diff --git a/src/libstd/rand/distributions.rs b/src/libstd/rand/distributions.rs
index 6d08b3c84bd..1cdf4d6da95 100644
--- a/src/libstd/rand/distributions.rs
+++ b/src/libstd/rand/distributions.rs
@@ -65,14 +65,14 @@ fn ziggurat<R:Rng>(rng: &mut R,
 ///
 /// # Example
 ///
-/// ~~~
+/// ```
 /// use std::rand::distributions::StandardNormal;
 ///
 /// fn main() {
 ///     let normal = 2.0 + (*rand::random::<StandardNormal>()) * 3.0;
 ///     printfln!("%f is from a N(2, 9) distribution", normal)
 /// }
-/// ~~~
+/// ```
 pub struct StandardNormal(f64);
 
 impl Rand for StandardNormal {
@@ -119,14 +119,14 @@ impl Rand for StandardNormal {
 ///
 /// # Example
 ///
-/// ~~~
+/// ```
 /// use std::rand::distributions::Exp1;
 ///
 /// fn main() {
 ///     let exp2 = (*rand::random::<Exp1>()) * 0.5;
 ///     printfln!("%f is from a Exp(2) distribution", exp2);
 /// }
-/// ~~~
+/// ```
 pub struct Exp1(f64);
 
 // This could be done via `-rng.gen::<f64>().ln()` but that is slower.
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 7b753f821d7..832978a0f10 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -21,7 +21,7 @@ distributions like normal and exponential.
 
 # Examples
 
-~~~ {.rust}
+```rust
 use std::rand;
 use std::rand::Rng;
 
@@ -31,16 +31,16 @@ fn main() {
         printfln!("int: %d, uint: %u", rng.gen(), rng.gen())
     }
 }
-~~~
+ ```
 
-~~~ {.rust}
+```rust
 use std::rand;
 
 fn main () {
     let tuple_ptr = rand::random::<~(f64, char)>();
     printfln!(tuple_ptr)
 }
-~~~
+ ```
 */
 
 use cast;
@@ -264,7 +264,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
@@ -273,7 +273,7 @@ pub trait Rng {
     ///    printfln!(x);
     ///    printfln!(rng.gen::<(float, bool)>());
     /// }
-    /// ~~~
+    /// ```
     #[inline(always)]
     fn gen<T: Rand>(&mut self) -> T {
         Rand::rand(self)
@@ -283,7 +283,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
@@ -292,7 +292,7 @@ pub trait Rng {
     ///    printfln!(x);
     ///    printfln!(rng.gen_vec::<(float, bool)>(5));
     /// }
-    /// ~~~
+    /// ```
     fn gen_vec<T: Rand>(&mut self, len: uint) -> ~[T] {
         vec::from_fn(len, |_| self.gen())
     }
@@ -308,7 +308,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
@@ -318,7 +318,7 @@ pub trait Rng {
     ///    let m: i16 = rng.gen_integer_range(-40, 400);
     ///    printfln!(m);
     /// }
-    /// ~~~
+    /// ```
     fn gen_integer_range<T: Rand + Int>(&mut self, low: T, high: T) -> T {
         assert!(low < high, "RNG.gen_integer_range called with low >= high");
         let range = (high - low).to_u64();
@@ -335,7 +335,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     /// use std::rand::Rng;
     ///
@@ -343,7 +343,7 @@ pub trait Rng {
     ///     let mut rng = rand::rng();
     ///     printfln!("%b", rng.gen_weighted_bool(3));
     /// }
-    /// ~~~
+    /// ```
     fn gen_weighted_bool(&mut self, n: uint) -> bool {
         n == 0 || self.gen_integer_range(0, n) == 0
     }
@@ -353,13 +353,13 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
     ///    println(rand::task_rng().gen_ascii_str(10));
     /// }
-    /// ~~~
+    /// ```
     fn gen_ascii_str(&mut self, len: uint) -> ~str {
         static GEN_ASCII_STR_CHARSET: &'static [u8] = bytes!("ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                                                              abcdefghijklmnopqrstuvwxyz\
@@ -381,14 +381,14 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
     ///     printfln!(rand::task_rng().choose_option([1,2,4,8,16,32]));
     ///     printfln!(rand::task_rng().choose_option([]));
     /// }
-    /// ~~~
+    /// ```
     fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
         if values.is_empty() {
             None
@@ -402,7 +402,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     /// use std::rand::Rng;
     ///
@@ -413,7 +413,7 @@ pub trait Rng {
     ///              rand::Weighted {weight: 2, item: 'c'}];
     ///     printfln!("%c", rng.choose_weighted(x));
     /// }
-    /// ~~~
+    /// ```
     fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
         self.choose_weighted_option(v).expect("Rng.choose_weighted: total weight is 0")
     }
@@ -423,7 +423,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     /// use std::rand::Rng;
     ///
@@ -434,7 +434,7 @@ pub trait Rng {
     ///              rand::Weighted {weight: 2, item: 'c'}];
     ///     printfln!(rng.choose_weighted_option(x));
     /// }
-    /// ~~~
+    /// ```
     fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
                                        -> Option<T> {
         let mut total = 0u;
@@ -460,7 +460,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     /// use std::rand::Rng;
     ///
@@ -471,7 +471,7 @@ pub trait Rng {
     ///              rand::Weighted {weight: 2, item: 'c'}];
     ///     printfln!(rng.weighted_vec(x));
     /// }
-    /// ~~~
+    /// ```
     fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
         let mut r = ~[];
         for item in v.iter() {
@@ -486,13 +486,13 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
     ///     printfln!(rand::task_rng().shuffle(~[1,2,3]));
     /// }
-    /// ~~~
+    /// ```
     fn shuffle<T>(&mut self, values: ~[T]) -> ~[T] {
         let mut v = values;
         self.shuffle_mut(v);
@@ -503,7 +503,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
@@ -514,7 +514,7 @@ pub trait Rng {
     ///    rng.shuffle_mut(y);
     ///    printfln!(y);
     /// }
-    /// ~~~
+    /// ```
     fn shuffle_mut<T>(&mut self, values: &mut [T]) {
         let mut i = values.len();
         while i >= 2u {
@@ -529,7 +529,7 @@ pub trait Rng {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// use std::rand;
     ///
     /// fn main() {
@@ -537,7 +537,7 @@ pub trait Rng {
     ///    let sample = rng.sample(range(1, 100), 5);
     ///    printfln!(sample);
     /// }
-    /// ~~~
+    /// ```
     fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
         let mut reservoir : ~[A] = vec::with_capacity(n);
         for (i, elem) in iter.enumerate() {
diff --git a/src/libstd/rt/io/buffered.rs b/src/libstd/rt/io/buffered.rs
index 7988f640687..3e801f28991 100644
--- a/src/libstd/rt/io/buffered.rs
+++ b/src/libstd/rt/io/buffered.rs
@@ -17,7 +17,7 @@
 //!
 //! # Examples
 //!
-//! ~~~
+//! ```
 //! let tcp_stream = TcpStream::connect(addr);
 //! let reader = BufferedReader::new(tcp_stream);
 //!
@@ -26,17 +26,17 @@
 //!     Some(nread) => println!("Read {} bytes", nread),
 //!     None => println!("At the end of the stream!")
 //! }
-//! ~~~
+//! ```
 //!
-//! ~~~
+//! ```
 //! let tcp_stream = TcpStream::connect(addr);
 //! let writer = BufferedWriter::new(tcp_stream);
 //!
 //! writer.write("hello, world".as_bytes());
 //! writer.flush();
-//! ~~~
+//! ```
 //!
-//! ~~~
+//! ```
 //! let tcp_stream = TcpStream::connect(addr);
 //! let stream = BufferedStream::new(tcp_stream);
 //!
@@ -48,7 +48,7 @@
 //!     Some(nread) => println!("Read {} bytes", nread),
 //!     None => println!("At the end of the stream!")
 //! }
-//! ~~~
+//! ```
 //!
 
 use prelude::*;
diff --git a/src/libstd/rt/io/file.rs b/src/libstd/rt/io/file.rs
index 2206f8bf6ae..b11ee014af9 100644
--- a/src/libstd/rt/io/file.rs
+++ b/src/libstd/rt/io/file.rs
@@ -477,7 +477,7 @@ pub trait FileSystemInfo {
 ///
 /// * Check if a file exists, reading from it if so
 ///
-/// ~~~{.rust}
+/// ```rust
 /// use std;
 /// use std::path::Path;
 /// use std::rt::io::file::{FileInfo, FileReader};
@@ -489,17 +489,17 @@ pub trait FileSystemInfo {
 ///     reader.read(mem);
 ///     // ...
 /// }
-/// ~~~
+/// ```
 ///
 /// * Is the given path a file?
 ///
-/// ~~~{.rust}
+/// ```rust
 /// let f = get_file_path_from_wherever();
 /// match f.is_file() {
 ///    true => doing_something_with_a_file(f),
 ///    _ => {}
 /// }
-/// ~~~
+/// ```
 pub trait FileInfo : FileSystemInfo {
     /// Whether the underlying implemention (be it a file path,
     /// or something else) points at a "regular file" on the FS. Will return
@@ -574,7 +574,7 @@ impl FileInfo for Path { }
 ///
 /// * Check if a directory exists, `mkdir`'ing it if not
 ///
-/// ~~~{.rust}
+/// ```rust
 /// use std;
 /// use std::path::Path;
 /// use std::rt::io::file::{DirectoryInfo};
@@ -583,11 +583,11 @@ impl FileInfo for Path { }
 /// if !dir.exists() {
 ///     dir.mkdir();
 /// }
-/// ~~~
+/// ```
 ///
 /// * Is the given path a directory? If so, iterate on its contents
 ///
-/// ~~~{.rust}
+/// ```rust
 /// fn visit_dirs(dir: &Path, cb: &fn(&Path)) {
 ///     if dir.is_dir() {
 ///         let contents = dir.readdir();
@@ -598,7 +598,7 @@ impl FileInfo for Path { }
 ///     }
 ///     else { fail!("nope"); }
 /// }
-/// ~~~
+/// ```
 trait DirectoryInfo : FileSystemInfo {
     /// Whether the underlying implemention (be it a file path,
     /// or something else) is pointing at a directory in the underlying FS.
@@ -971,4 +971,4 @@ mod test {
             dir.rmdir();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/rt/io/mock.rs b/src/libstd/rt/io/mock.rs
index b580b752bd9..c46e1372c64 100644
--- a/src/libstd/rt/io/mock.rs
+++ b/src/libstd/rt/io/mock.rs
@@ -47,4 +47,4 @@ impl MockWriter {
 impl Writer for MockWriter {
     fn write(&mut self, buf: &[u8]) { (self.write)(buf) }
     fn flush(&mut self) { (self.flush)() }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 92dc62490ed..6563ac2e96f 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -71,14 +71,14 @@ before reporting whether it succeeded or failed. A watching parent will only
 report success if it succeeded and all its children also reported success;
 otherwise, it will report failure. This is most useful for writing test cases:
 
-~~~
+ ```
 #[test]
 fn test_something_in_another_task {
     do spawn {
         assert!(collatz_conjecture_is_false());
     }
 }
-~~~
+ ```
 
 Here, as the child task will certainly outlive the parent task, we might miss
 the failure of the child when deciding whether or not the test case passed.
diff --git a/src/libstd/std.rs b/src/libstd/std.rs
index 5c1bac7418e..46d655e6379 100644
--- a/src/libstd/std.rs
+++ b/src/libstd/std.rs
@@ -58,8 +58,7 @@ they contained the following prologue:
 #[crate_type = "lib"];
 
 #[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
-      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-      passes = "strip-hidden")];
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico")];
 
 // Don't link to std. We are std.
 #[no_std];
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index c94d8f366a6..8dc6f783fbe 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -37,13 +37,13 @@ there are three common kinds of strings in rust:
 
 As an example, here's a few different kinds of strings.
 
-~~~{.rust}
+```rust
 let owned_string = ~"I am an owned string";
 let managed_string = @"This string is garbage-collected";
 let borrowed_string1 = "This string is borrowed with the 'static lifetime";
 let borrowed_string2: &str = owned_string;   // owned strings can be borrowed
 let borrowed_string3: &str = managed_string; // managed strings can also be borrowed
-~~~
+ ```
 
 From the example above, you can see that rust has 3 different kinds of string
 literals. The owned/managed literals correspond to the owned/managed string
@@ -67,12 +67,12 @@ to that string. With these guarantees, strings can easily transition between
 being mutable/immutable with the same benefits of having mutable strings in
 other languages.
 
-~~~{.rust}
+```rust
 let mut buf = ~"testing";
 buf.push_char(' ');
 buf.push_str("123");
 assert_eq!(buf, ~"testing 123");
-~~~
+ ```
 
 # Representation
 
@@ -1513,10 +1513,10 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let v: ~[char] = "abc åäö".iter().collect();
     /// assert_eq!(v, ~['a', 'b', 'c', ' ', 'å', 'ä', 'ö']);
-    /// ~~~
+    /// ```
     #[inline]
     fn iter(&self) -> CharIterator<'self> {
         CharIterator{string: *self}
@@ -1558,13 +1558,13 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let v: ~[&str] = "Mary had a little lamb".split_iter(' ').collect();
     /// assert_eq!(v, ~["Mary", "had", "a", "little", "lamb"]);
     ///
     /// let v: ~[&str] = "abc1def2ghi".split_iter(|c: char| c.is_digit()).collect();
     /// assert_eq!(v, ~["abc", "def", "ghi"]);
-    /// ~~~
+    /// ```
     #[inline]
     fn split_iter<Sep: CharEq>(&self, sep: Sep) -> CharSplitIterator<'self, Sep> {
         CharSplitIterator {
@@ -1597,10 +1597,10 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let v: ~[&str] = "A.B.".split_terminator_iter('.').collect();
     /// assert_eq!(v, ~["A", "B"]);
-    /// ~~~
+    /// ```
     #[inline]
     fn split_terminator_iter<Sep: CharEq>(&self, sep: Sep)
         -> CharSplitIterator<'self, Sep> {
@@ -1615,10 +1615,10 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let v: ~[&str] = "Mary had a little lamb".rsplit_iter(' ').collect();
     /// assert_eq!(v, ~["lamb", "little", "a", "had", "Mary"]);
-    /// ~~~
+    /// ```
     #[inline]
     fn rsplit_iter<Sep: CharEq>(&self, sep: Sep) -> CharRSplitIterator<'self, Sep> {
         self.split_iter(sep).invert()
@@ -1655,10 +1655,10 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let v: ~[&str] = "abcXXXabcYYYabc".split_str_iter("abc").collect()
     /// assert_eq!(v, ["", "XXX", "YYY", ""]);
-    /// ~~~
+    /// ```
     #[inline]
     fn split_str_iter(&self, sep: &'self str) -> StrSplitIterator<'self> {
         StrSplitIterator {
@@ -1853,11 +1853,11 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// assert_eq!("11foo1bar11".trim_chars(&'1'), "foo1bar")
     /// assert_eq!("12foo1bar12".trim_chars(& &['1', '2']), "foo1bar")
     /// assert_eq!("123foo1bar123".trim_chars(&|c: char| c.is_digit()), "foo1bar")
-    /// ~~~
+    /// ```
     #[inline]
     fn trim_chars<C: CharEq>(&self, to_trim: &C) -> &'self str {
         self.trim_left_chars(to_trim).trim_right_chars(to_trim)
@@ -1871,11 +1871,11 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// assert_eq!("11foo1bar11".trim_left_chars(&'1'), "foo1bar11")
     /// assert_eq!("12foo1bar12".trim_left_chars(& &['1', '2']), "foo1bar12")
     /// assert_eq!("123foo1bar123".trim_left_chars(&|c: char| c.is_digit()), "foo1bar123")
-    /// ~~~
+    /// ```
     #[inline]
     fn trim_left_chars<C: CharEq>(&self, to_trim: &C) -> &'self str {
         match self.find(|c: char| !to_trim.matches(c)) {
@@ -1892,11 +1892,11 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// assert_eq!("11foo1bar11".trim_right_chars(&'1'), "11foo1bar")
     /// assert_eq!("12foo1bar12".trim_right_chars(& &['1', '2']), "12foo1bar")
     /// assert_eq!("123foo1bar123".trim_right_chars(&|c: char| c.is_digit()), "123foo1bar")
-    /// ~~~
+    /// ```
     #[inline]
     fn trim_right_chars<C: CharEq>(&self, to_trim: &C) -> &'self str {
         match self.rfind(|c: char| !to_trim.matches(c)) {
@@ -2000,7 +2000,7 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let s = "中华Việt Nam";
     /// let i = 0u;
     /// while i < s.len() {
@@ -2008,11 +2008,11 @@ impl<'self> StrSlice<'self> for &'self str {
     ///     printfln!("%u: %c", i, ch);
     ///     i = next;
     /// }
-    /// ~~~
+    /// ```
     ///
     /// # Example output
     ///
-    /// ~~~
+    /// ```
     /// 0: 中
     /// 3: 华
     /// 6: V
@@ -2023,7 +2023,7 @@ impl<'self> StrSlice<'self> for &'self str {
     /// 13: N
     /// 14: a
     /// 15: m
-    /// ~~~
+    /// ```
     ///
     /// # Arguments
     ///
@@ -2228,7 +2228,7 @@ impl<'self> StrSlice<'self> for &'self str {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let string = "a\nb\nc";
     /// let mut lines = ~[];
     /// for line in string.line_iter() { lines.push(line) }
@@ -2236,7 +2236,7 @@ impl<'self> StrSlice<'self> for &'self str {
     /// assert!(string.subslice_offset(lines[0]) == 0); // &"a"
     /// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
     /// assert!(string.subslice_offset(lines[2]) == 4); // &"c"
-    /// ~~~
+    /// ```
     #[inline]
     fn subslice_offset(&self, inner: &str) -> uint {
         do self.as_imm_buf |a, a_len| {
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index b52dd3a906b..1dbc644c8e5 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -26,11 +26,11 @@
  *
  * # Example
  *
- * ~~~
+ * ```
  * do spawn {
  *     log(error, "Hello, World!");
  * }
- * ~~~
+ * ```
  */
 
 #[allow(missing_doc)];
@@ -565,7 +565,7 @@ pub fn failing() -> bool {
  *
  * # Example
  *
- * ~~~
+ * ```
  * do task::unkillable {
  *     // detach / deschedule / destroy must all be called together
  *     rustrt::rust_port_detach(po);
@@ -573,7 +573,7 @@ pub fn failing() -> bool {
  *     task::deschedule();
  *     rustrt::rust_port_destroy(po);
  * }
- * ~~~
+ * ```
  */
 pub fn unkillable<U>(f: &fn() -> U) -> U {
     use rt::task::Task;
@@ -602,7 +602,7 @@ pub fn unkillable<U>(f: &fn() -> U) -> U {
  *
  * # Example
  *
- * ~~~
+ * ```
  * do task::unkillable {
  *     do task::rekillable {
  *          // Task is killable
diff --git a/src/libstd/unstable/finally.rs b/src/libstd/unstable/finally.rs
index ba5986aa4ab..c1365a44bc9 100644
--- a/src/libstd/unstable/finally.rs
+++ b/src/libstd/unstable/finally.rs
@@ -14,13 +14,13 @@ stack closures that emulates Java-style try/finally blocks.
 
 # Example
 
-~~~
+ ```
 do || {
     ...
 }.finally {
     always_run_this();
 }
-~~~
+ ```
 */
 
 use ops::Drop;
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index ae217d6af31..e54717053e9 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -16,10 +16,10 @@ The `vec` module contains useful code to help work with vector values.
 Vectors are Rust's list type. Vectors contain zero or more values of
 homogeneous types:
 
-~~~ {.rust}
+```rust
 let int_vector = [1,2,3];
 let str_vector = ["one", "two", "three"];
-~~~
+ ```
 
 This is a big module, but for a high-level overview:
 
@@ -40,11 +40,11 @@ case.
 An example is the method `.slice(a, b)` that returns an immutable "view" into
 a vector or a vector slice from the index interval `[a, b)`:
 
-~~~ {.rust}
+```rust
 let numbers = [0, 1, 2];
 let last_numbers = numbers.slice(1, 3);
 // last_numbers is now &[1, 2]
-~~~
+ ```
 
 Traits defined for the `~[T]` type, like `OwnedVector`, can only be called
 on such vectors. These methods deal with adding elements or otherwise changing
@@ -53,11 +53,11 @@ the allocation of the vector.
 An example is the method `.push(element)` that will add an element at the end
 of the vector:
 
-~~~ {.rust}
+```rust
 let mut numbers = ~[0, 1, 2];
 numbers.push(7);
 // numbers is now ~[0, 1, 2, 7];
-~~~
+ ```
 
 ## Implementations of other traits
 
@@ -74,12 +74,12 @@ The method `iter()` returns an iteration value for a vector or a vector slice.
 The iterator yields borrowed pointers to the vector's elements, so if the element
 type of the vector is `int`, the element type of the iterator is `&int`.
 
-~~~ {.rust}
+```rust
 let numbers = [0, 1, 2];
 for &x in numbers.iter() {
     println!("{} is a number!", x);
 }
-~~~
+ ```
 
 * `.rev_iter()` returns an iterator with the same values as `.iter()`,
   but going in the reverse order, starting with the back element.
@@ -1000,12 +1000,12 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      * Print the adjacent pairs of a vector (i.e. `[1,2]`, `[2,3]`,
      * `[3,4]`):
      *
-     * ~~~ {.rust}
+     * ```rust
      * let v = &[1,2,3,4];
      * for win in v.window_iter() {
      *     printfln!(win);
      * }
-     * ~~~
+     * ```
      *
      */
     fn window_iter(self, size: uint) -> WindowIter<'self, T> {
@@ -1029,12 +1029,12 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
      * Print the vector two elements at a time (i.e. `[1,2]`,
      * `[3,4]`, `[5]`):
      *
-     * ~~~ {.rust}
+     * ```rust
      * let v = &[1,2,3,4,5];
      * for win in v.chunk_iter() {
      *     printfln!(win);
      * }
-     * ~~~
+     * ```
      *
      */
     fn chunk_iter(self, size: uint) -> ChunkIter<'self, T> {
@@ -1279,13 +1279,13 @@ impl<T> OwnedVector<T> for ~[T] {
     ///
     /// # Examples
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let v = ~[~"a", ~"b"];
     /// for s in v.move_iter() {
     ///   // s has type ~str, not &~str
     ///   println(s);
     /// }
-    /// ~~~
+    /// ```
     fn move_iter(self) -> MoveIterator<T> {
         MoveIterator { v: self, idx: 0 }
     }
@@ -1449,11 +1449,11 @@ impl<T> OwnedVector<T> for ~[T] {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let mut a = ~[~1];
     /// a.push_all_move(~[~2, ~3, ~4]);
     /// assert!(a == ~[~1, ~2, ~3, ~4]);
-    /// ~~~
+    /// ```
     #[inline]
     fn push_all_move(&mut self, mut rhs: ~[T]) {
         let self_len = self.len();
@@ -1697,11 +1697,11 @@ impl<T:Clone> OwnedCopyableVector<T> for ~[T] {
     ///
     /// # Example
     ///
-    /// ~~~ {.rust}
+    /// ```rust
     /// let mut a = ~[1];
     /// a.push_all([2, 3, 4]);
     /// assert!(a == ~[1, 2, 3, 4]);
-    /// ~~~
+    /// ```
     #[inline]
     fn push_all(&mut self, rhs: &[T]) {
         let new_len = self.len() + rhs.len();