---

yaml
---
r: 30768
b: refs/heads/incoming
c: e956ede
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 8b13912a839a5e0336fa285d9b62c1337e17b165
+refs/heads/incoming: e956edeb55f3f2875fd2fe00cb21bd48f29c1842
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/bool.rs

@@ -8,43 +8,39 @@
 
 use cmp::Eq;
 
-export not, and, or, xor, implies;
-export eq, ne, is_true, is_false;
-export from_str, to_str, all_values, to_bit;
-
 /// Negation / inverse
-pure fn not(v: bool) -> bool { !v }
+pub pure fn not(v: bool) -> bool { !v }
 
 /// Conjunction
-pure fn and(a: bool, b: bool) -> bool { a && b }
+pub pure fn and(a: bool, b: bool) -> bool { a && b }
 
 /// Disjunction
-pure fn or(a: bool, b: bool) -> bool { a || b }
+pub pure fn or(a: bool, b: bool) -> bool { a || b }
 
 /**
  * Exclusive or
  *
  * Identical to `or(and(a, not(b)), and(not(a), b))`
  */
-pure fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
+pub pure fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 
 /// Implication in the logic, i.e. from `a` follows `b`
-pure fn implies(a: bool, b: bool) -> bool { !a || b }
+pub pure fn implies(a: bool, b: bool) -> bool { !a || b }
 
 /// true if truth values `a` and `b` are indistinguishable in the logic
-pure fn eq(a: bool, b: bool) -> bool { a == b }
+pub pure fn eq(a: bool, b: bool) -> bool { a == b }
 
 /// true if truth values `a` and `b` are distinguishable in the logic
-pure fn ne(a: bool, b: bool) -> bool { a != b }
+pub pure fn ne(a: bool, b: bool) -> bool { a != b }
 
 /// true if `v` represents truth in the logic
-pure fn is_true(v: bool) -> bool { v }
+pub pure fn is_true(v: bool) -> bool { v }
 
 /// true if `v` represents falsehood in the logic
-pure fn is_false(v: bool) -> bool { !v }
+pub pure fn is_false(v: bool) -> bool { !v }
 
 /// Parse logic value from `s`
-pure fn from_str(s: &str) -> Option<bool> {
+pub pure fn from_str(s: &str) -> Option<bool> {
     if s == "true" {
         Some(true)
     } else if s == "false" {
@@ -55,40 +51,40 @@ pure fn from_str(s: &str) -> Option<bool> {
 }
 
 /// Convert `v` into a string
-pure fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } }
+pub pure fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } }
 
 /**
  * Iterates over all truth values by passing them to `blk` in an unspecified
  * order
  */
-fn all_values(blk: fn(v: bool)) {
+pub fn all_values(blk: fn(v: bool)) {
     blk(true);
     blk(false);
 }
 
 /// converts truth value to an 8 bit byte
-pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
+pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 impl bool : cmp::Eq {
     pure fn eq(other: &bool) -> bool { self == (*other) }
     pure fn ne(other: &bool) -> bool { self != (*other) }
 }
 
 #[test]
-fn test_bool_from_str() {
+pub fn test_bool_from_str() {
     do all_values |v| {
         assert Some(v) == from_str(bool::to_str(v))
     }
 }
 
 #[test]
-fn test_bool_to_str() {
+pub fn test_bool_to_str() {
     assert to_str(false) == ~"false";
     assert to_str(true) == ~"true";
 }
 
 #[test]
-fn test_bool_to_bit() {
+pub fn test_bool_to_bit() {
     do all_values |v| {
         assert to_bit(v) == if is_true(v) { 1u8 } else { 0u8 };
     }