auto merge of #6771 : thestinger/rust/highlight, r=luqmana

This works with pandoc linked against highlighting-kate >= 0.5.3.8. It seems to just be a no-op with earlier versions, because I successfully ran this through `try`.

This also fixes some consistency issues (like making `Example`/`Examples` always a header and always using three tildes).

Author: bors

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}
  * extern mod std;
  * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -370,7 +370,10 @@ pub impl<T:Const + Owned> RWARC<T> {
      * See sync::rwlock.write_downgrade(). The RWWriteMode token must be used
      * to obtain the &mut T, and can be transformed into a RWReadMode token by
      * calling downgrade(), after which a &T can be obtained instead.
-     * ~~~
+     *
+     * # Example
+     *
+     * ~~~ {.rust}
      * do arc.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...

src/libextra/base64.rs

@@ -28,17 +28,17 @@ impl<'self> ToBase64 for &'self [u8] {
     /**
      * Turn a vector of `u8` bytes into a base64 string.
      *
-     * *Example*:
+     * # Example
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
      *     println(fmt!("%s", str));
      * }
-     * ~~~~
+     * ~~~
      */
     fn to_base64(&self) -> ~str {
         let mut s = ~"";
@@ -91,17 +91,17 @@ impl<'self> ToBase64 for &'self str {
      * Convert any string (literal, `@`, `&`, or `~`) to base64 encoding.
      *
      *
-     * *Example*:
+     * # Example
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
      *     println(fmt!("%s",str));
      * }
-     * ~~~~
+     * ~~~
      *
      */
     fn to_base64(&self) -> ~str {
@@ -118,9 +118,9 @@ impl FromBase64 for ~[u8] {
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
      *
-     * *Example*:
+     * # Example
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -131,7 +131,7 @@ impl FromBase64 for ~[u8] {
      *     let bytes = str.from_base64();
      *     println(fmt!("%?",bytes));
      * }
-     * ~~~~
+     * ~~~
      */
     fn from_base64(&self) -> ~[u8] {
         if self.len() % 4u != 0u { fail!("invalid base64 length"); }
@@ -196,11 +196,11 @@ impl FromBase64 for ~str {
      * You can use the `from_bytes` function in `core::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
-     * *Example*:
+     * # Example
      *
      * This converts a string literal to base64 and back.
      *
-     * ~~~~
+     * ~~~ {.rust}
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -214,7 +214,7 @@ impl FromBase64 for ~str {
      *     let result_str = str::from_bytes(bytes);
      *     println(fmt!("%s",result_str));
      * }
-     * ~~~~
+     * ~~~
      */
     fn from_base64(&self) -> ~[u8] {
         str::to_bytes(*self).from_base64()

src/libextra/flatpipes.rs

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-~~~
+~~~ {.rust}
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {

src/libextra/future.rs

@@ -14,7 +14,7 @@
  *
  * # Example
  *
- * ~~~
+ * ~~~ {.rust}
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = std::future::spawn (|| fib(5000) );

src/libextra/net_tcp.rs

@@ -466,7 +466,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  * Here, the `new_conn` is used in conjunction with `accept` from within
  * a task spawned by the `new_connect_cb` passed into `listen`
  *
- * ~~~~~~~~~~~
+ * ~~~ {.rust}
  * do net::tcp::listen(remote_ip, remote_port, backlog, iotask,
  *     // this callback is ran once after the connection is successfully
  *     // set up
@@ -497,7 +497,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  *       None => ()
  *     }
  * };
- * ~~~~~~~~~~~
+ * ~~~
  *
  * # Arguments
  *

src/libextra/sync.rs

@@ -545,7 +545,10 @@ pub impl RWlock {
      * the meantime (such as unlocking and then re-locking as a reader would
      * do). The block takes a "write mode token" argument, which can be
      * transformed into a "read mode token" by calling downgrade(). Example:
-     * ~~~
+     *
+     * # Example
+     *
+     * ~~~ {.rust}
      * do lock.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |condvar| {
      *         ... exclusive access ...

src/libstd/bool.rs

@@ -43,10 +43,13 @@ use from_str::FromStr;
 * Negation of a boolean value.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::not(true)
 * false
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::not(false)
 * true
 * ~~~
@@ -57,10 +60,13 @@ pub fn not(v: bool) -> bool { !v }
 * Conjunction of two boolean values.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::and(true, false)
 * false
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::and(true, true)
 * true
 * ~~~
@@ -71,10 +77,13 @@ pub fn and(a: bool, b: bool) -> bool { a && b }
 * Disjunction of two boolean values.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::or(true, false)
 * true
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::or(false, false)
 * false
 * ~~~
@@ -87,10 +96,13 @@ pub fn or(a: bool, b: bool) -> bool { a || b }
 * 'exclusive or' is identical to `or(and(a, not(b)), and(not(a), b))`.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::xor(true, false)
 * true
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::xor(true, true)
 * false
 * ~~~
@@ -105,10 +117,12 @@ pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 * 'if a then b' is equivalent to `!a || b`.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::implies(true, true)
 * true
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::implies(true, false)
 * false
 * ~~~
@@ -121,10 +135,13 @@ pub fn implies(a: bool, b: bool) -> bool { !a || b }
 * Two booleans are equal if they have the same value.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::eq(false, true)
 * false
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::eq(false, false)
 * true
 * ~~~
@@ -137,10 +154,13 @@ pub fn eq(a: bool, b: bool) -> bool { a == b }
 * Two booleans are not equal if they have different values.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::ne(false, true)
 * true
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::ne(false, false)
 * false
 * ~~~
@@ -151,10 +171,13 @@ pub fn ne(a: bool, b: bool) -> bool { a != b }
 * Is a given boolean value true?
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::is_true(true)
 * true
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::is_true(false)
 * false
 * ~~~
@@ -165,10 +188,13 @@ pub fn is_true(v: bool) -> bool { v }
 * Is a given boolean value false?
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::is_false(false)
 * true
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::is_false(true)
 * false
 * ~~~
@@ -181,13 +207,18 @@ pub fn is_false(v: bool) -> bool { !v }
 * Yields an `Option<bool>`, because `str` may or may not actually be parseable.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> FromStr::from_str::<bool>("true")
 * Some(true)
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> FromStr::from_str::<bool>("false")
 * Some(false)
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> FromStr::from_str::<bool>("not even a boolean")
 * None
 * ~~~
@@ -206,10 +237,13 @@ impl FromStr for bool {
 * Convert a `bool` to a `str`.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::to_str(true)
 * "true"
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::to_str(false)
 * "false"
 * ~~~
@@ -237,10 +271,13 @@ pub fn all_values(blk: &fn(v: bool)) {
 * Convert a `bool` to a `u8`.
 *
 * # Examples
-* ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::to_bit(true)
 * 1
 * ~~~
+*
+* ~~~ {.rust}
 * rusti> std::bool::to_bit(false)
 * 0
 * ~~~

src/libstd/io.rs

@@ -1009,8 +1009,9 @@ pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
 /**
 * Gives a `Reader` that allows you to read values from standard input.
 *
-* # Examples
-* ~~~
+* # Example
+*
+* ~~~ {.rust}
 * let stdin = core::io::stdin();
 * let line = stdin.read_line();
 * core::io::print(line);
@@ -1572,8 +1573,9 @@ pub fn buffered_file_writer(path: &Path) -> Result<@Writer, ~str> {
 /**
 * Gives a `Writer` which allows you to write to the standard output.
 *
-* # Examples
-* ~~~
+* # Example
+*
+* ~~~ {.rust}
 * let stdout = core::io::stdout();
 * stdout.write_str("hello\n");
 * ~~~
@@ -1583,8 +1585,9 @@ pub fn stdout() -> @Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) }
 /**
 * Gives a `Writer` which allows you to write to standard error.
 *
-* # Examples
-* ~~~
+* # Example
+*
+* ~~~ {.rust}
 * let stderr = core::io::stderr();
 * stderr.write_str("hello\n");
 * ~~~
@@ -1597,8 +1600,9 @@ pub fn stderr() -> @Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
 * This string will not have an implicit newline at the end. If you want
 * an implicit newline, please see `println`.
 *
-* # Examples
-* ~~~
+* # Example
+*
+* ~~~ {.rust}
 * // print is imported into the prelude, and so is always available.
 * print("hello");
 * ~~~
@@ -1612,8 +1616,9 @@ pub fn print(s: &str) {
 *
 * If you do not want an implicit newline, please see `print`.
 *
-* # Examples
-* ~~~
+* # Example
+*
+* ~~~ {.rust}
 * // println is imported into the prelude, and so is always available.
 * println("hello");
 * ~~~