---

yaml
---
r: 11749
b: refs/heads/master
c: b22556a
h: refs/heads/master
i:
  11747: f843447
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a0521971b1b9a3203c250591991092a445b50586
+refs/heads/master: b22556a6f818845cd400ad58065a83916ba591a7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/libcore/bool.rs

@@ -10,55 +10,36 @@ export from_str, to_str, all_values, to_bit;
 #[doc = "The type of boolean logic values"]
 type t = bool;
 
-#[doc(
-  brief = "Negation/Inverse"
-)]
+#[doc = "Negation/Inverse"]
 pure fn not(v: t) -> t { !v }
 
-#[doc(
-  brief = "Conjunction"
-)]
+#[doc = "Conjunction"]
 pure fn and(a: t, b: t) -> t { a && b }
 
-#[doc(
-  brief = "Disjunction"
-)]
+#[doc = "Disjunction"]
 pure fn or(a: t, b: t) -> t { a || b }
 
-#[doc(
-  brief = "Exclusive or, i.e. `or(and(a, not(b)), and(not(a), b))`"
-)]
+#[doc = "Exclusive or, i.e. `or(and(a, not(b)), and(not(a), b))`"]
 pure fn xor(a: t, b: t) -> t { (a && !b) || (!a && b) }
 
-#[doc(
-  brief = "Implication in the logic, i.e. from `a` follows `b`"
-)]
+#[doc = "Implication in the logic, i.e. from `a` follows `b`"]
 pure fn implies(a: t, b: t) -> t { !a || b }
 
-#[doc(
-  brief = "true if truth values `a` and `b` \
-           are indistinguishable in the logic"
-)]
+#[doc = "
+true if truth values `a` and `b` are indistinguishable in the logic
+"]
 pure fn eq(a: t, b: t) -> bool { a == b }
 
-#[doc(
-  brief = "true if truth values `a` and `b` are distinguishable in the logic"
-)]
+#[doc = "true if truth values `a` and `b` are distinguishable in the logic"]
 pure fn ne(a: t, b: t) -> bool { a != b }
 
-#[doc(
-  brief = "true if `v` represents truth in the logic"
-)]
+#[doc = "true if `v` represents truth in the logic"]
 pure fn is_true(v: t) -> bool { v }
 
-#[doc(
-  brief = "true if `v` represents falsehood in the logic"
-)]
+#[doc = "true if `v` represents falsehood in the logic"]
 pure fn is_false(v: t) -> bool { !v }
 
-#[doc(
-  brief = "Parse logic value from `s`"
-)]
+#[doc = "Parse logic value from `s`"]
 pure fn from_str(s: str) -> option<t> {
     alt check s {
       "true" { some(true) }
@@ -67,23 +48,19 @@ pure fn from_str(s: str) -> option<t> {
     }
 }
 
-#[doc(
-  brief = "Convert `v` into a string"
-)]
+#[doc = "Convert `v` into a string"]
 pure fn to_str(v: t) -> str { if v { "true" } else { "false" } }
 
-#[doc(
-  brief = "Iterates over all truth values by passing them to `blk` \
-           in an unspecified order"
-)]
+#[doc = "
+Iterates over all truth values by passing them to `blk` in an unspecified
+order
+"]
 fn all_values(blk: fn(v: t)) {
     blk(true);
     blk(false);
 }
 
-#[doc(
-  brief = "converts truth value to an 8 bit byte"
-)]
+#[doc = "converts truth value to an 8 bit byte"]
 pure fn to_bit(v: t) -> u8 { if v { 1u8 } else { 0u8 } }
 
 #[test]

trunk/src/libcore/box.rs

@@ -1,9 +1,9 @@
+#[doc = "Operations on shared box types"];
+
 export ptr_eq;
 
-#[doc(
-  brief = "Determine if two shared boxes point to the same object"
-)]
 pure fn ptr_eq<T>(a: @T, b: @T) -> bool unchecked {
+    #[doc = "Determine if two shared boxes point to the same object"];
     ptr::addr_of(*a) == ptr::addr_of(*b)
 }
 

trunk/src/libcore/char.rs

@@ -45,66 +45,72 @@ import is_XID_start = unicode::derived_property::XID_Start;
 import is_XID_continue = unicode::derived_property::XID_Continue;
 
 
-#[doc(
-  brief = "Indicates whether a character is in lower case, defined \
-           in terms of the Unicode General Category 'Ll'."
-)]
+#[doc = "
+Indicates whether a character is in lower case, defined
+in terms of the Unicode General Category 'Ll'
+"]
 pure fn is_lowercase(c: char) -> bool {
     ret unicode::general_category::Ll(c);
 }
 
-#[doc(
-  brief = "Indicates whether a character is in upper case, defined \
-           in terms of the Unicode General Category 'Lu'."
-)]
+#[doc = "
+Indicates whether a character is in upper case, defined
+in terms of the Unicode General Category 'Lu'.
+"]
 pure fn is_uppercase(c: char) -> bool {
     ret unicode::general_category::Lu(c);
 }
 
-#[doc(
-  brief = "Indicates whether a character is whitespace, defined in \
-           terms of the Unicode General Categories 'Zs', 'Zl', 'Zp' \
-           additional 'Cc'-category control codes in the range [0x09, 0x0d]"
-)]
+#[doc = "
+Indicates whether a character is whitespace, defined in
+terms of the Unicode General Categories 'Zs', 'Zl', 'Zp'
+additional 'Cc'-category control codes in the range [0x09, 0x0d]
+"]
 pure fn is_whitespace(c: char) -> bool {
     ret ('\x09' <= c && c <= '\x0d')
         || unicode::general_category::Zs(c)
         || unicode::general_category::Zl(c)
         || unicode::general_category::Zp(c);
 }
 
-#[doc(
-  brief = "Indicates whether a character is alphanumeric, defined \
-            in terms of the Unicode General Categories 'Nd', \
-            'Nl', 'No' and the Derived Core Property 'Alphabetic'."
-)]
+#[doc = "
+Indicates whether a character is alphanumeric, defined
+in terms of the Unicode General Categories 'Nd',
+'Nl', 'No' and the Derived Core Property 'Alphabetic'.
+"]
 pure fn is_alphanumeric(c: char) -> bool {
     ret unicode::derived_property::Alphabetic(c) ||
         unicode::general_category::Nd(c) ||
         unicode::general_category::Nl(c) ||
         unicode::general_category::No(c);
 }
 
-#[doc( brief = "Indicates whether the character is an ASCII character" )]
+#[doc = "Indicates whether the character is an ASCII character"]
 pure fn is_ascii(c: char) -> bool {
    c - ('\x7F' & c) == '\x00'
 }
 
-#[doc( brief = "Indicates whether the character is numeric (Nd, Nl, or No)" )]
+#[doc = "Indicates whether the character is numeric (Nd, Nl, or No)"]
 pure fn is_digit(c: char) -> bool {
     ret unicode::general_category::Nd(c) ||
         unicode::general_category::Nl(c) ||
         unicode::general_category::No(c);
 }
 
-#[doc(
-  brief = "Convert a char to the corresponding digit. \
-           Safety note: This function fails if `c` is not a valid char",
-  return = "If `c` is between '0' and '9', the corresponding value \
-            between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is \
-            'b' or 'B', 11, etc. Returns none if the char does not \
-            refer to a digit in the given radix."
-)]
+#[doc = "
+Convert a char to the corresponding digit.
+
+# Safety note
+
+This function fails if `c` is not a valid char
+
+# Return value
+
+If `c` is between '0' and '9', the corresponding value
+between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is
+'b' or 'B', 11, etc. Returns none if the char does not
+refer to a digit in the given radix.
+"]
 pure fn to_digit(c: char, radix: uint) -> option<uint> {
     let val = alt c {
       '0' to '9' { c as uint - ('0' as uint) }
@@ -119,9 +125,7 @@ pure fn to_digit(c: char, radix: uint) -> option<uint> {
 /*
  FIXME: works only on ASCII
 */
-#[doc(
-  brief = "Convert a char to the corresponding lower case."
-)]
+#[doc = "Convert a char to the corresponding lower case."]
 pure fn to_lower(c: char) -> char {
     alt c {
       'A' to 'Z' { ((c as u8) + 32u8) as char }
@@ -132,20 +136,21 @@ pure fn to_lower(c: char) -> char {
 /*
  FIXME: works only on ASCII
 */
-#[doc(
-  brief = "Convert a char to the corresponding upper case."
-)]
+#[doc = "Convert a char to the corresponding upper case."]
 pure fn to_upper(c: char) -> char {
     alt c {
       'a' to 'z' { ((c as u8) - 32u8) as char }
       _ { c }
     }
 }
 
-#[doc(
-  brief =  "Compare two chars.",
-  return = "-1 if a<b, 0 if a==b, +1 if a>b"
-)]
+#[doc = "
+Compare two chars
+
+# Return value
+
+-1 if a < b, 0 if a == b, +1 if a > b
+"]
 pure fn cmp(a: char, b: char) -> int {
     ret  if b > a { -1 }
     else if b < a { 1 }