stdlib: added (2,3,4)-valued logic ADTs

This is useful for writing caches and perhaps in typestate predicates.
It also adds a companion module for bool with from_str, to_str, ... fns.

4 files changed, 292 insertions, 0 deletions

diff --git a/src/test/stdtest/bool.rs b/src/test/stdtest/bool.rs
new file mode 100644
index 00000000000..2f91b7aa1e1
--- /dev/null
+++ b/src/test/stdtest/bool.rs
@@ -0,0 +1,23 @@
+use std;
+
+import std::bool;
+
+#[test]
+fn test_bool_from_str() {
+    bool::all_values { |v|
+        assert v == bool::from_str(bool::to_str(v))
+    }
+}
+
+#[test]
+fn test_bool_to_str() {
+    assert bool::to_str(false) == "false";
+    assert bool::to_str(true) == "true";
+}
+
+#[test]
+fn test_bool_to_bit() {
+    bool::all_values { |v|
+        assert bool::to_bit(v) == if bool::is_true(v) { 1u8 } else { 0u8 };
+    }
+}
\ No newline at end of file
diff --git a/src/test/stdtest/four.rs b/src/test/stdtest/four.rs
new file mode 100644
index 00000000000..d0af7a393d3
--- /dev/null
+++ b/src/test/stdtest/four.rs
@@ -0,0 +1,149 @@
+use std;
+
+import std::tri;
+import std::four;
+
+fn eq1(a: four::t, b: four::t) -> bool { four::eq(a , b) }
+fn ne1(a: four::t, b: four::t) -> bool { four::ne(a , b) }
+
+fn eq2(a: four::t, b: four::t) -> bool { eq1( a, b ) && eq1( b, a ) }
+
+#[test]
+fn test_four_req_eq() {
+    four::all_values { |a|
+        four::all_values { |b|
+            assert if a == b { eq1( a, b ) } else { ne1( a, b ) };
+        }
+    }
+}
+
+#[test]
+fn test_four_and_symmetry() {
+    four::all_values { |a|
+        four::all_values { |b|
+            assert eq1( four::and(a ,b), four::and(b, a) );
+        }
+    }
+}
+
+#[test]
+fn test_four_xor_symmetry() {
+    four::all_values { |a|
+        four::all_values { |b|
+            assert eq1( four::and(a ,b), four::and(b, a) );
+        }
+    }
+}
+
+#[test]
+fn test_four_or_symmetry() {
+    four::all_values { |a|
+        four::all_values { |b|
+            assert eq1( four::or(a ,b), four::or(b, a) );
+        }
+    }
+}
+
+fn to_tup(v: four::t) -> (bool, bool) {
+    alt v {
+      0u8 { (false, false) }
+      1u8 { (false, true) }
+      2u8 { (true, false) }
+      3u8 { (true, true) }
+    }
+}
+
+#[test]
+fn test_four_not() {
+    four::all_values { |a|
+        let (x, y) = to_tup(a);
+        assert to_tup(four::not(a)) == (y, x);
+    };
+}
+
+
+#[test]
+fn test_four_and() {
+    four::all_values { |a|
+        four::all_values { |b|
+            let (y1, x1) = to_tup(a);
+            let (y2, x2) = to_tup(b);
+            let (y3, x3) = to_tup(four::and(a, b));
+
+            assert (x3, y3) == (x1 && x2, y1 || y2);
+        }
+    };
+}
+
+#[test]
+fn test_four_or() {
+    four::all_values { |a|
+        four::all_values { |b|
+            let (y1, x1) = to_tup(a);
+            let (y2, x2) = to_tup(b);
+            let (y3, x3) = to_tup(four::or(a, b));
+
+            assert (x3, y3) == (x1 || x2, y1 && y2);
+        }
+    };
+}
+
+#[test]
+fn test_four_implies() {
+    four::all_values { |a|
+        four::all_values { |b|
+            let (_, x1) = to_tup(a);
+            let (y2, x2) = to_tup(b);
+            let (y3, x3) = to_tup(four::implies(a, b));
+
+            assert (x3, y3) == (!x1 || x2, x1 && y2);
+        }
+    };
+}
+
+#[test]
+fn test_four_is_true() {
+    assert !four::is_true(four::none);
+    assert !four::is_true(four::false);
+    assert four::is_true(four::true);
+    assert four::is_true(four::both);
+}
+
+#[test]
+fn test_four_is_false() {
+    assert four::is_false(four::none);
+    assert four::is_false(four::false);
+    assert !four::is_false(four::true);
+    assert !four::is_false(four::both);
+}
+
+#[test]
+fn test_four_from_str() {
+    four::all_values { |v|
+        assert eq1( v, four::from_str(four::to_str(v)) );
+    }
+}
+
+#[test]
+fn test_four_to_str() {
+    assert four::to_str(four::none) == "none";
+    assert four::to_str(four::false) == "false";
+    assert four::to_str(four::true) == "true" ;
+    assert four::to_str(four::both) == "both";
+}
+
+#[test]
+fn test_four_to_tri() {
+    assert tri::eq( four::to_trit(four::true), tri::true );
+    assert tri::eq( four::to_trit(four::false), tri::false );
+    assert tri::eq( four::to_trit(four::none), tri::unknown );
+    log four::to_trit(four::both);
+    assert tri::eq( four::to_trit(four::both), tri::unknown );
+}
+
+#[test]
+fn test_four_to_bit() {
+    four::all_values { |v|
+        assert four::to_bit(v) == if four::is_true(v) { 1u8 } else { 0u8 };
+    }
+}
\ No newline at end of file
diff --git a/src/test/stdtest/stdtest.rc b/src/test/stdtest/stdtest.rc
index fd3722e1938..289c1221c92 100644
--- a/src/test/stdtest/stdtest.rc
+++ b/src/test/stdtest/stdtest.rc
@@ -1,12 +1,14 @@
 use std;
 
 mod bitv;
+mod bool;
 mod box;
 mod char;
 mod comm;
 mod deque;
 mod either;
 mod float;
+mod four;
 mod fs;
 mod getopts;
 mod int;
@@ -32,6 +34,7 @@ mod str;
 mod sys;
 mod task;
 mod test;
+mod tri;
 mod treemap;
 mod uint;
 mod unsafe;
diff --git a/src/test/stdtest/tri.rs b/src/test/stdtest/tri.rs
new file mode 100644
index 00000000000..4ea87c1270e
--- /dev/null
+++ b/src/test/stdtest/tri.rs
@@ -0,0 +1,117 @@
+use std;
+
+import std::tri;
+
+pure fn eq1(a: tri::t, b: tri::t) -> bool { tri::eq(a , b) }
+pure fn ne1(a: tri::t, b: tri::t) -> bool { tri::ne(a , b) }
+
+pure fn eq2(a: tri::t, b: tri::t) -> bool { eq1( a, b ) && eq1( b, a ) }
+
+#[test]
+fn test_eq2() {
+    tri::all_values { |a|
+        tri::all_values { |b|
+            assert if a == b { eq1( a, b ) } else { ne1( a, b ) }
+        }
+    }
+}
+
+#[test]
+fn test_tri_and_symmetry() {
+    tri::all_values { |a|
+        tri::all_values { |b|
+            assert eq1( tri::and(a ,b), tri::and(b, a) );
+        }
+    }
+}
+
+#[test]
+fn test_tri_or_symmetry() {
+    tri::all_values { |a|
+        tri::all_values { |b|
+            assert eq1( tri::or(a ,b), tri::or(b, a) );
+        }
+    }
+}
+
+#[test]
+fn test_tri_xor_symmetry() {
+    tri::all_values { |a|
+        tri::all_values { |b|
+            assert eq1( tri::xor(a ,b), tri::xor(b, a) );
+        }
+    }
+}
+
+#[test]
+fn test_tri_not() {
+    assert eq2( tri::not(tri::true), tri::false);
+    assert eq2( tri::not(tri::unknown), tri::unknown);
+    assert eq2( tri::not(tri::false), tri::true);
+}
+
+#[test]
+fn test_tri_and() {
+    assert eq2( tri::and(tri::true, tri::true), tri::true);
+    assert eq2( tri::and(tri::true, tri::false), tri::false);
+    assert eq2( tri::and(tri::true, tri::unknown), tri::unknown);
+    assert eq2( tri::and(tri::false, tri::false), tri::false);
+    assert eq2( tri::and(tri::false, tri::unknown), tri::false);
+    assert eq2( tri::and(tri::unknown, tri::unknown), tri::unknown);
+}
+
+#[test]
+fn test_tri_or() {
+    assert eq2( tri::or(tri::true, tri::true), tri::true);
+    assert eq2( tri::or(tri::true, tri::false), tri::true);
+    assert eq2( tri::or(tri::true, tri::unknown), tri::true);
+    assert eq2( tri::or(tri::false, tri::false), tri::false);
+    assert eq2( tri::or(tri::false, tri::unknown), tri::unknown);
+    assert eq2( tri::or(tri::unknown, tri::unknown), tri::unknown);
+}
+
+#[test]
+fn test_tri_xor() {
+    assert eq2( tri::xor(tri::true, tri::true), tri::false);
+    assert eq2( tri::xor(tri::false, tri::false), tri::false);
+    assert eq2( tri::xor(tri::true, tri::false), tri::true);
+    assert eq2( tri::xor(tri::true, tri::unknown), tri::unknown);
+    assert eq2( tri::xor(tri::false, tri::unknown), tri::unknown);
+    assert eq2( tri::xor(tri::unknown, tri::unknown), tri::unknown);
+}
+
+#[test]
+fn test_tri_implies() {
+    assert eq2( tri::implies(tri::false, tri::false), tri::true);
+    assert eq2( tri::implies(tri::false, tri::unknown), tri::true);
+    assert eq2( tri::implies(tri::false, tri::true), tri::true);
+
+    assert eq2( tri::implies(tri::unknown, tri::false), tri::unknown);
+    assert eq2( tri::implies(tri::unknown, tri::unknown), tri::unknown);
+    assert eq2( tri::implies(tri::unknown, tri::true), tri::true);
+
+    assert eq2( tri::implies(tri::true, tri::false), tri::false);
+    assert eq2( tri::implies(tri::true, tri::unknown), tri::unknown);
+    assert eq2( tri::implies(tri::true, tri::true), tri::true);
+}
+
+#[test]
+fn test_tri_from_str() {
+    tri::all_values { |v|
+        assert eq2( v, tri::from_str(tri::to_str(v)));
+    }
+}
+
+#[test]
+fn test_tri_to_str() {
+    assert tri::to_str(tri::false) == "false";
+    assert tri::to_str(tri::unknown) == "unknown";
+    assert tri::to_str(tri::true) == "true";
+}
+
+#[test]
+fn test_tri_to_bit() {
+    tri::all_values { |v|
+        assert tri::to_bit(v) == if tri::is_true(v) { 1u8 } else { 0u8 };
+    }
+}
\ No newline at end of file