core: Convert to rustdoc

Author: brson

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]

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

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 }

src/libcore/comm.rs

@@ -1,6 +1,5 @@
-#[doc(
-  brief = "Communication between tasks",
-  desc  = "
+#[doc = "
+Communication between tasks
 
 Communication between tasks is facilitated by ports (in the receiving
 task), and channels (in the sending task). Any number of channels may
@@ -11,15 +10,19 @@ vectors, strings, and records, tags, tuples and unique boxes (`~T`)
 thereof. Most notably, shared boxes (`@T`) may not be transmitted
 across channels.
 
-Example:
+# Example
 
-    let p = comm::port();
-    task::spawn(comm::chan(p), fn (c: chan<str>) {
-        comm::send(c, \"Hello, World\");
-    });
-    io::println(comm::recv(p));
+~~~
+let po = comm::port();
+let ch = comm::chan(po);
 
-")];
+task::spawn {||
+    comm::send(ch, \"Hello, World\");
+});
+
+io::println(comm::recv(p));
+~~~
+"];
 
 import sys;
 import task;
@@ -65,18 +68,16 @@ type port_id = int;
 
 // It's critical that this only have one variant, so it has a record
 // layout, and will work in the rust_task structure in task.rs.
-#[doc(
-  brief = "A communication endpoint that can send messages. \
-           Channels send messages to ports.",
-  desc = "Each channel is bound to a port when the channel is \
-          constructed, so the destination port for a channel \
-          must exist before the channel itself. \
-          Channels are weak: a channel does not keep the port it \
-          is bound to alive. If a channel attempts to send data \
-          to a dead port that data will be silently dropped. \
-          Channels may be duplicated and themselves transmitted \
-          over other channels."
-)]
+#[doc = "
+A communication endpoint that can send messages
+
+Each channel is bound to a port when the channel is constructed, so
+the destination port for a channel must exist before the channel
+itself.  Channels are weak: a channel does not keep the port it is
+bound to alive. If a channel attempts to send data to a dead port that
+data will be silently dropped.  Channels may be duplicated and
+themselves transmitted over other channels.
+"]
 enum chan<T: send> {
     chan_t(task_id, port_id)
 }
@@ -104,21 +105,19 @@ resource port_ptr<T: send>(po: *rust_port) {
     rustrt::del_port(po);
 }
 
-#[doc(
-  brief = "A communication endpoint that can receive messages. \
-           Ports receive messages from channels.",
-  desc = "Each port has a unique per-task identity and may not \
-          be replicated or transmitted. If a port value is \
-          copied, both copies refer to the same port. \
-          Ports may be associated with multiple <chan>s."
-)]
+#[doc = "
+A communication endpoint that can receive messages
+
+Each port has a unique per-task identity and may not be replicated or
+transmitted. If a port value is copied, both copies refer to the same
+port.  Ports may be associated with multiple `chan`s.
+"]
 enum port<T: send> { port_t(@port_ptr<T>) }
 
-#[doc(
-  brief = "Sends data over a channel. The sent data is moved \
-           into the channel, whereupon the caller loses \
-           access to it."
-)]
+#[doc = "
+Sends data over a channel. The sent data is moved into the channel,
+whereupon the caller loses access to it.
+"]
 fn send<T: send>(ch: chan<T>, -data: T) {
     let chan_t(t, p) = ch;
     let res = rustrt::chan_id_send(sys::get_type_desc::<T>(), t, p, data);
@@ -129,23 +128,18 @@ fn send<T: send>(ch: chan<T>, -data: T) {
     task::yield();
 }
 
-#[doc(
-  brief = "Constructs a port."
-)]
+#[doc = "Constructs a port"]
 fn port<T: send>() -> port<T> {
     port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>())))
 }
 
-#[doc(
-  brief = "Receive from a port. \
-           If no data is available on the port then the task will \
-           block until data becomes available."
-)]
+#[doc = "
+Receive from a port.  If no data is available on the port then the
+task will block until data becomes available.
+"]
 fn recv<T: send>(p: port<T>) -> T { recv_(***p) }
 
-#[doc(
-  brief = "Receive on a raw port pointer"
-)]
+#[doc = "Receive on a raw port pointer"]
 fn recv_<T: send>(p: *rust_port) -> T {
     // FIXME: Due to issue 1185 we can't use a return pointer when
     // calling C code, and since we can't create our own return
@@ -218,10 +212,10 @@ fn peek<T: send>(p: port<T>) -> bool {
     rustrt::rust_port_size(***p) != 0u as ctypes::size_t
 }
 
-#[doc(
-  brief = "Constructs a channel. The channel is bound to the \
-           port used to construct it."
-)]
+#[doc = "
+Constructs a channel. The channel is bound to the port used to
+construct it.
+"]
 fn chan<T: send>(p: port<T>) -> chan<T> {
     chan_t(rustrt::get_task_id(), rustrt::get_port_id(***p))
 }