rustdoc: Change all code-blocks with a script

find src -name '*.rs' | xargs sed -i '' 's/~~~.*{\.rust}/```rust/g'
    find src -name '*.rs' | xargs sed -i '' 's/ ~~~$/ ```/g'
    find src -name '*.rs' | xargs sed -i '' 's/^~~~$/ ```/g'

src/libextra/arc.rs

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without Arc, a copy would have to be made for each task.
  *
- * ~~~ {.rust}
+ * ```rust
  * extern mod std;
  * use extra::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -34,7 +34,7 @@
  *           // Work with the local numbers
  *       }
  *   }
- * ~~~
+ * ```
  */
 
 #[allow(missing_doc)];
@@ -440,7 +440,7 @@ impl<T:Freeze + Send> RWArc<T> {
      *
      * # Example
      *
-     * ~~~ {.rust}
+     * ```rust
      * do arc.write_downgrade |mut write_token| {
      *     do write_token.write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...
@@ -450,7 +450,7 @@ impl<T:Freeze + Send> RWArc<T> {
      *         ... shared access with immutable state ...
      *     }
      * }
-     * ~~~
+     * ```
      */
     pub fn write_downgrade<U>(&self, blk: &fn(v: RWWriteMode<T>) -> U) -> U {
         unsafe {

src/libextra/base64.rs

@@ -62,7 +62,7 @@ impl<'self> ToBase64 for &'self [u8] {
      *
      * # Example
      *
-     * ~~~ {.rust}
+     * ```rust
      * extern mod extra;
      * use extra::base64::{ToBase64, standard};
      *
@@ -70,7 +70,7 @@ impl<'self> ToBase64 for &'self [u8] {
      *     let str = [52,32].to_base64(standard);
      *     printfln!("%s", str);
      * }
-     * ~~~
+     * ```
      */
     fn to_base64(&self, config: Config) -> ~str {
         let bytes = match config.char_set {
@@ -170,7 +170,7 @@ impl<'self> FromBase64 for &'self str {
      *
      * This converts a string literal to base64 and back.
      *
-     * ~~~ {.rust}
+     * ```rust
      * extern mod extra;
      * use extra::base64::{ToBase64, FromBase64, standard};
      * use std::str;
@@ -183,7 +183,7 @@ impl<'self> FromBase64 for &'self str {
      *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
-     * ~~~
+     * ```
      */
     fn from_base64(&self) -> Result<~[u8], ~str> {
         let mut r = ~[];

src/libextra/flatpipes.rs

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-~~~ {.rust}
+```rust
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {
@@ -37,7 +37,7 @@ do task::spawn || {
 for i in range(0, 10) {
     assert @i == port.recv()
 }
-~~~
+ ```
 
 # Safety Note
 

src/libextra/future.rs

@@ -14,13 +14,13 @@
  *
  * # Example
  *
- * ~~~ {.rust}
+ * ```rust
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = extra::future::spawn (|| fib(5000) );
  * make_a_sandwich();
  * printfln!("fib(5000) = %?", delayed_fib.get())
- * ~~~
+ * ```
  */
 
 #[allow(missing_doc)];

src/libextra/glob.rs

@@ -51,18 +51,18 @@ pub struct GlobIterator {
  * Consider a directory `/media/pictures` containing only the files `kittens.jpg`,
  * `puppies.jpg` and `hamsters.gif`:
  *
- * ~~~ {.rust}
+ * ```rust
  * for path in glob("/media/pictures/*.jpg") {
  *     println(path.to_str());
  * }
- * ~~~
+ * ```
  *
  * The above code will print:
  *
- * ~~~
+ * ```
  * /media/pictures/kittens.jpg
  * /media/pictures/puppies.jpg
- * ~~~
+ * ```
  */
 pub fn glob(pattern: &str) -> GlobIterator {
     glob_with(pattern, MatchOptions::new())
@@ -270,11 +270,11 @@ impl Pattern {
      *
      * # Example
      *
-     * ~~~ {.rust}
+     * ```rust
      * assert!(Pattern::new("c?t").matches("cat"));
      * assert!(Pattern::new("k[!e]tteh").matches("kitteh"));
      * assert!(Pattern::new("d*g").matches("doog"));
-     * ~~~
+     * ```
      */
     pub fn matches(&self, str: &str) -> bool {
         self.matches_with(str, MatchOptions::new())
@@ -492,13 +492,13 @@ impl MatchOptions {
      *
      * This function always returns this value:
      *
-     * ~~~ {.rust}
+     * ```rust
      * MatchOptions {
      *     case_sensitive: true,
      *     require_literal_separator: false.
      *     require_literal_leading_dot: false
      * }
-     * ~~~
+     * ```
      */
     pub fn new() -> MatchOptions {
         MatchOptions {

src/libextra/hex.rs

@@ -27,7 +27,7 @@ impl<'self> ToHex for &'self [u8] {
      *
      * # Example
      *
-     * ~~~ {.rust}
+     * ```rust
      * extern mod extra;
      * use extra::hex::ToHex;
      *
@@ -35,7 +35,7 @@ impl<'self> ToHex for &'self [u8] {
      *     let str = [52,32].to_hex();
      *     printfln!("%s", str);
      * }
-     * ~~~
+     * ```
      */
     fn to_hex(&self) -> ~str {
         let mut v = vec::with_capacity(self.len() * 2);
@@ -70,7 +70,7 @@ impl<'self> FromHex for &'self str {
      *
      * This converts a string literal to hexadecimal and back.
      *
-     * ~~~ {.rust}
+     * ```rust
      * extern mod extra;
      * use extra::hex::{FromHex, ToHex};
      * use std::str;
@@ -83,7 +83,7 @@ impl<'self> FromHex for &'self str {
      *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
-     * ~~~
+     * ```
      */
     fn from_hex(&self) -> Result<~[u8], ~str> {
         // This may be an overestimate if there is any whitespace

src/libextra/sync.rs

@@ -578,7 +578,7 @@ impl RWLock {
      *
      * # Example
      *
-     * ~~~ {.rust}
+     * ```rust
      * do lock.write_downgrade |mut write_token| {
      *     do write_token.write_cond |condvar| {
      *         ... exclusive access ...
@@ -588,7 +588,7 @@ impl RWLock {
      *         ... shared access ...
      *     }
      * }
-     * ~~~
+     * ```
      */
     pub fn write_downgrade<U>(&self, blk: &fn(v: RWLockWriteMode) -> U) -> U {
         // Implementation slightly different from the slicker 'write's above.

src/libextra/uuid.rs

@@ -28,7 +28,7 @@ unlikely.
 
 To create a new random (V4) UUID and print it out in hexadecimal form:
 
-~~~ {.rust}
+```rust
 extern mod extra;
 use extra::uuid::Uuid;
 
@@ -36,7 +36,7 @@ fn main() {
     let uuid1 = Uuid::new_v4();
     println(uuid1.to_str());
 }
-~~~
+ ```
 
 # Strings
 

src/librustc/middle/typeck/infer/doc.rs

@@ -240,4 +240,4 @@ We make use of a trait-like impementation strategy to consolidate
 duplicated code between subtypes, GLB, and LUB computations.  See the
 section on "Type Combining" below for details.
 
-*/
+*/

src/librustpkg/testsuite/pass/src/fancy-lib/foo.rs

@@ -9,4 +9,4 @@
 // except according to those terms.
 
 pub fn do_nothing() {
-}
+}

src/librustpkg/testsuite/pass/src/install-paths/bench.rs

@@ -14,4 +14,4 @@ fn g() {
     while(x < 1000) {
         x += 1;
     }
-}
+}

src/librustpkg/testsuite/pass/src/simple-lib/src/foo.rs

@@ -9,4 +9,4 @@
 // except according to those terms.
 
 pub fn do_nothing() {
-}
+}

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 {

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
     ///

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 {

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");

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) }
 }

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);

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>;
 }
 

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])));
-~~~
+ ```
 
 */
 

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() }

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() }

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() }

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 {

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 {

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"
 };
-~~~
+ ```
 
 */
 

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.

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() {

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::*;

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();
         }
     }
-}
+}

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)() }
-}
+}

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.

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| {

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

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;

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();

src/libsyntax/ext/deriving/generic.rs

@@ -59,7 +59,7 @@ associated with. It is only not `None` when the associated field has
 an identifier in the source code. For example, the `x`s in the
 following snippet
 
-~~~
+ ```
 struct A { x : int }
 
 struct B(int);
@@ -82,7 +82,7 @@ represented as a count of 0.
 
 The following simplified `Eq` is used for in-code examples:
 
-~~~
+ ```
 trait Eq {
     fn eq(&self, other: &Self);
 }
@@ -91,7 +91,7 @@ impl Eq for int {
         *self == *other
     }
 }
-~~~
+ ```
 
 Some examples of the values of `SubstructureFields` follow, using the
 above `Eq`, `A`, `B` and `C`.
@@ -100,50 +100,50 @@ above `Eq`, `A`, `B` and `C`.
 
 When generating the `expr` for the `A` impl, the `SubstructureFields` is
 
-~~~
+ ```
 Struct(~[(Some(<ident of x>),
          <expr for &self.x>,
          ~[<expr for &other.x])])
-~~~
+ ```
 
 For the `B` impl, called with `B(a)` and `B(b)`,
 
-~~~
+ ```
 Struct(~[(None,
           <expr for &a>
           ~[<expr for &b>])])
-~~~
+ ```
 
 ## Enums
 
 When generating the `expr` for a call with `self == C0(a)` and `other
 == C0(b)`, the SubstructureFields is
 
-~~~
+ ```
 EnumMatching(0, <ast::variant for C0>,
              ~[None,
                <expr for &a>,
                ~[<expr for &b>]])
-~~~
+ ```
 
 For `C1 {x}` and `C1 {x}`,
 
-~~~
+ ```
 EnumMatching(1, <ast::variant for C1>,
              ~[Some(<ident of x>),
                <expr for &self.x>,
                ~[<expr for &other.x>]])
-~~~
+ ```
 
 For `C0(a)` and `C1 {x}` ,
 
-~~~
+ ```
 EnumNonMatching(~[(0, <ast::variant for B0>,
                    ~[(None, <expr for &a>)]),
                   (1, <ast::variant for B1>,
                    ~[(Some(<ident of x>),
                       <expr for &other.x>)])])
-~~~
+ ```
 
 (and vice versa, but with the order of the outermost list flipped.)
 
@@ -158,7 +158,7 @@ StaticStruct(<ast::struct_def of B>, Left(1))
 
 StaticEnum(<ast::enum_def of C>, ~[(<ident of C0>, Left(1)),
                                    (<ident of C1>, Right(~[<ident of x>]))])
-~~~
+ ```
 
 */
 
@@ -547,7 +547,7 @@ impl<'self> MethodDef<'self> {
     }
 
     /**
-    ~~~
+    ```
     #[deriving(Eq)]
     struct A { x: int, y: int }
 
@@ -565,7 +565,7 @@ impl<'self> MethodDef<'self> {
             }
         }
     }
-    ~~~
+    ```
     */
     fn expand_struct_method_body(&self,
                                  cx: @ExtCtxt,
@@ -638,7 +638,7 @@ impl<'self> MethodDef<'self> {
     }
 
     /**
-    ~~~
+    ```
     #[deriving(Eq)]
     enum A {
         A1
@@ -661,7 +661,7 @@ impl<'self> MethodDef<'self> {
             }
         }
     }
-    ~~~
+    ```
     */
     fn expand_enum_method_body(&self,
                                cx: @ExtCtxt,
@@ -681,13 +681,13 @@ impl<'self> MethodDef<'self> {
     /**
     Creates the nested matches for an enum definition recursively, i.e.
 
-    ~~~
+    ```
     match self {
        Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... },
        Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... },
        ...
     }
-    ~~~
+    ```
 
     It acts in the most naive way, so every branch (and subbranch,
     subsubbranch, etc) exists, not just the ones where all the variants in
@@ -1058,10 +1058,10 @@ pub fn cs_fold(use_foldl: bool,
 Call the method that is being derived on all the fields, and then
 process the collected results. i.e.
 
-~~~
+ ```
 f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1),
               self_2.method(__arg_1_2, __arg_2_2)])
-~~~
+ ```
 */
 #[inline]
 pub fn cs_same_method(f: &fn(@ExtCtxt, Span, ~[@Expr]) -> @Expr,

src/libsyntax/ext/expand.rs

@@ -944,7 +944,7 @@ pub fn std_macros() -> @str {
 
     # Example
 
-    ~~~ {.rust}
+    ```rust
     fn choose_weighted_item(v: &[Item]) -> Item {
         assert!(!v.is_empty());
         let mut so_far = 0u;
@@ -958,7 +958,7 @@ pub fn std_macros() -> @str {
         // type checker that it isn't possible to get down here
         unreachable!();
     }
-    ~~~
+    ```
 
     */
     macro_rules! unreachable (() => (

src/test/compile-fail/borrowck-anon-fields-struct.rs

@@ -34,4 +34,4 @@ fn same_variant() {
 }
 
 fn main() {
-}
+}

src/test/compile-fail/borrowck-anon-fields-tuple.rs

@@ -32,4 +32,4 @@ fn same_variant() {
 }
 
 fn main() {
-}
+}

src/test/compile-fail/borrowck-anon-fields-variant.rs

@@ -40,4 +40,4 @@ fn same_variant() {
 }
 
 fn main() {
-}
+}

src/test/compile-fail/borrowck-bad-nested-calls-free.rs

@@ -40,4 +40,4 @@ fn explicit() {
         rewrite(&mut a)); //~ ERROR cannot borrow
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/borrowck-bad-nested-calls-move.rs

@@ -40,4 +40,4 @@ fn explicit() {
         a); //~ ERROR cannot move
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/borrowck-move-in-irrefut-pat.rs

@@ -13,4 +13,4 @@ fn let_pat() {
     //~^ ERROR cannot move out of dereference of & pointer
 }
 
-pub fn main() {}
+pub fn main() {}

src/test/compile-fail/borrowck-move-mut-base-ptr.rs

@@ -12,4 +12,4 @@ fn foo(t0: &mut int) {
 }
 
 fn main() {
-}
+}

src/test/compile-fail/borrowck-swap-mut-base-ptr.rs

@@ -13,4 +13,4 @@ fn foo<'a>(mut t0: &'a mut int,
 }
 
 fn main() {
-}
+}

src/test/compile-fail/cast-immutable-mutable-trait.rs

@@ -25,4 +25,4 @@ fn main() {
     let s = @S { unused: 0 };
     let _s2 = s as @mut T; //~ error: types differ in mutability
     let _s3 = &s as &mut T; //~ error: types differ in mutability
-}
+}

src/test/compile-fail/cast-vector-to-unsafe-nonstatic.rs

@@ -11,4 +11,4 @@
 fn main() {
     let foo = ['h' as u8, 'i' as u8, 0 as u8];
     let bar = &foo as *u8; //~ ERROR mismatched types
-}
+}

src/test/compile-fail/closure-bounds-not-builtin.rs

@@ -5,4 +5,4 @@ fn take(f: &fn:Foo()) {
     //~^ ERROR only the builtin traits can be used as closure or object bounds
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/coherence_inherent.rs

@@ -42,4 +42,4 @@ mod NoImport {
     }
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/coherence_inherent_cc.rs

@@ -35,4 +35,4 @@ mod NoImport {
     }
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/deprecated-auto-code.rs

@@ -12,4 +12,4 @@
 #[auto_decode] //~ ERROR: `#[auto_decode]` is deprecated
 struct A;
 
-fn main() {}
+fn main() {}

src/test/compile-fail/issue-2995.rs

@@ -12,4 +12,4 @@ fn bad (p: *int) {
     let _q: &int = p as ∫ //~ ERROR non-scalar cast
 }
 
-fn main() { }
+fn main() { }

src/test/compile-fail/issue-4736.rs

@@ -12,4 +12,4 @@ struct NonCopyable(());
 
 fn main() {
     let z = NonCopyable{ p: () }; //~ ERROR structure has no field named `p`
-}
+}

src/test/compile-fail/issue-6762.rs

@@ -21,4 +21,4 @@ fn main()
 
       twice(x);
       invoke(sq);
-}
+}

src/test/compile-fail/lub-if.rs

@@ -49,4 +49,4 @@ pub fn opt_str3<'a>(maybestr: &'a Option<~str>) -> &'static str {
 }
 
 
-fn main() {}
+fn main() {}

src/test/compile-fail/lub-match.rs

@@ -52,4 +52,4 @@ pub fn opt_str3<'a>(maybestr: &'a Option<~str>) -> &'static str {
     }
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/main-wrong-location.rs

@@ -12,4 +12,4 @@ mod m {
     // An inferred main entry point (that doesn't use #[main])
     // must appear at the top of the crate
     fn main() { } //~ NOTE here is a function named 'main'
-}
+}

src/test/compile-fail/regions-free-region-ordering-callee.rs

@@ -34,4 +34,4 @@ fn ordering4<'a, 'b>(a: &'a uint, b: &'b uint, x: &fn(&'a &'b uint)) {
     let z: Option<&'a &'b uint> = None;
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/regions-free-region-ordering-caller.rs

@@ -37,4 +37,4 @@ fn call4<'a, 'b>(a: &'a uint, b: &'b uint) {
 }
 
 
-fn main() {}
+fn main() {}

src/test/compile-fail/regions-ref-in-fn-arg.rs

@@ -8,4 +8,4 @@ fn arg_closure() -> &'static int {
     with(|~ref x| x) //~ ERROR borrowed value does not live long enough
 }
 
-fn main() {}
+fn main() {}

src/test/compile-fail/suppressed-error.rs

@@ -11,4 +11,4 @@
 fn main() {
     let (x, y) = (); //~ ERROR expected `()` but found tuple (types differ)
     return x;
-}
+}

src/test/compile-fail/tag-variant-disr-dup.rs

@@ -20,4 +20,4 @@ enum color {
     white = 0x000000,
 }
 
-fn main() { }
+fn main() { }

src/test/compile-fail/type-parameter-names.rs

@@ -3,4 +3,4 @@
 
 fn foo<Foo, Bar>(x: Foo) -> Bar { x } //~ ERROR expected `Bar` but found `Foo`
 
-fn main() {}
+fn main() {}

src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs

@@ -47,4 +47,4 @@ fn fun2() {
 pub fn main() {
     fun1();
     fun2();
-}
+}

src/test/run-pass/deriving-via-extension-struct-empty.rs

@@ -14,4 +14,4 @@ struct Foo;
 pub fn main() {
   assert_eq!(Foo, Foo);
   assert!(!(Foo != Foo));
-}
+}

src/test/run-pass/issue-4252.rs

@@ -34,4 +34,4 @@ impl<T: X> Drop for Z<T> {
 fn main() {
     let y = Y;
     let _z = Z{x: y};
-}
+}

src/test/run-pass/xc_conditions_client.rs

@@ -37,4 +37,4 @@ pub fn main() {
         let x = trouble();
         assert_eq!(x,12345);
     }
-}
+}

src/test/run-pass/xc_conditions_client_4.rs

@@ -29,4 +29,4 @@ pub fn main() {
         let t = SThunk { x : 10 };
         assert_eq!(xcc::callback(t), xcc::Red)
     }
-}
+}