---

yaml
---
r: 4121
b: refs/heads/master
c: f8968d1
h: refs/heads/master
i:
  4119: c3ee283
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: aea537779e01359cf8da6944218362d44bfaee83
+refs/heads/master: f8968d1e719ca8e80429e9f26f75941ccef3c346

trunk/src/test/bench/shootout-fasta.rs

@@ -21,24 +21,24 @@ obj myrandom(mutable u32 last) {
     }
 }
 
-type aminoacids = tup(char, u32);
+type aminoacids = rec(char ch, u32 prob);
 
 fn make_cumulative(vec[aminoacids] aa) -> vec[aminoacids] {
     let u32 cp = 0u32;
     let vec[aminoacids] ans = [];
-    for (aminoacids a in aa) { cp += a._1; ans += [tup(a._0, cp)]; }
+    for (aminoacids a in aa) { cp += a.prob; ans += [rec(ch=a.ch, prob=cp)]; }
     ret ans;
 }
 
 fn select_random(u32 r, vec[aminoacids] genelist) -> char {
-    if (r < genelist.(0)._1) { ret genelist.(0)._0; }
+    if (r < genelist.(0).prob) { ret genelist.(0).ch; }
     fn bisect(vec[aminoacids] v, uint lo, uint hi, u32 target) -> char {
         if (hi > lo + 1u) {
             let uint mid = lo + (hi - lo) / 2u;
-            if (target < v.(mid)._1) {
+            if (target < v.(mid).prob) {
                 be bisect(v, lo, mid, target);
             } else { be bisect(v, mid, hi, target); }
-        } else { ret v.(hi)._0; }
+        } else { ret v.(hi).ch; }
     }
     ret bisect(genelist, 0u, vec::len[aminoacids](genelist) - 1u, r);
 }
@@ -65,16 +65,18 @@ fn make_repeat_fasta(str id, str desc, str s, int n) {
     if (str::byte_len(op) > 0u) { log op; }
 }
 
+fn acid(char ch, u32 prob) { ret rec(ch=ch, prob=prob); }
+
 fn main(vec[str] args) {
     let vec[aminoacids] iub =
-        make_cumulative([tup('a', 27u32), tup('c', 12u32), tup('g', 12u32),
-                         tup('t', 27u32), tup('B', 2u32), tup('D', 2u32),
-                         tup('H', 2u32), tup('K', 2u32), tup('M', 2u32),
-                         tup('N', 2u32), tup('R', 2u32), tup('S', 2u32),
-                         tup('V', 2u32), tup('W', 2u32), tup('Y', 2u32)]);
+        make_cumulative([acid('a', 27u32), acid('c', 12u32), acid('g', 12u32),
+                         acid('t', 27u32), acid('B', 2u32), acid('D', 2u32),
+                         acid('H', 2u32), acid('K', 2u32), acid('M', 2u32),
+                         acid('N', 2u32), acid('R', 2u32), acid('S', 2u32),
+                         acid('V', 2u32), acid('W', 2u32), acid('Y', 2u32)]);
     let vec[aminoacids] homosapiens =
-        make_cumulative([tup('a', 30u32), tup('c', 20u32), tup('g', 20u32),
-                         tup('t', 30u32)]);
+        make_cumulative([acid('a', 30u32), acid('c', 20u32), acid('g', 20u32),
+                         acid('t', 30u32)]);
     let str alu =
         "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" +
             "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" +

trunk/src/test/bench/task-perf-word-count.rs

@@ -134,9 +134,10 @@ mod map_reduce {
 
         map(input, bind emit(intermediates, ctrl, _, _));
 
-        for each(@tup(str, chan[reduce_proto]) kv in intermediates.items()) {
+        for each(@rec(str key, chan[reduce_proto] val) kv
+                 in intermediates.items()) {
             // log_err "sending done to reducer for " + kv._0;
-            kv._1 <| release;
+            kv.val <| release;
         }
 
         ctrl <| mapper_done;
@@ -228,9 +229,10 @@ mod map_reduce {
             }
         }
 
-        for each(@tup(str, chan[reduce_proto]) kv in reducers.items()) {
+        for each(@rec(str key, chan[reduce_proto] val) kv
+                 in reducers.items()) {
             // log_err "sending done to reducer for " + kv._0;
-            kv._1 <| done;
+            kv.val <| done;
         }
 
         // log_err #fmt("joining %u tasks", ivec::len(tasks));

trunk/src/test/compile-fail/binop-add-tup-assign.rs

@@ -1,7 +1,7 @@
 // xfail-stage0
-// error-pattern:+ cannot be applied to type `tup(bool)`
+// error-pattern:+ cannot be applied to type `rec(bool x)`
 
 fn main() {
-  auto x = tup(true);
-  x += tup(false);
+  auto x = rec(x=true);
+  x += rec(x=false);
 }

trunk/src/test/compile-fail/binop-add-tup.rs

@@ -1,6 +1,6 @@
 // xfail-stage0
-// error-pattern:+ cannot be applied to type `tup(bool)`
+// error-pattern:+ cannot be applied to type `rec(bool x)`
 
 fn main() {
-  auto x = tup(true) + tup(false);
+  auto x = rec(x=true) + rec(x=false);
 }

trunk/src/test/compile-fail/for-loop-decl.rs

@@ -9,9 +9,10 @@ type var_info = rec(uint a, uint b);
 fn bitv_to_str(fn_info enclosing, bitv::t v) -> str {
   auto s = "";
 
-  // error is that the value type in the hash map is var_info, not a tuple
-  for each (@tup(uint, tup(uint, uint)) p in enclosing.vars.items()) {
-    if (bitv::get(v, p._1._0)) {
+  // error is that the value type in the hash map is var_info, not a box
+  for each (@rec(uint key, @uint val) p
+            in enclosing.vars.items()) {
+    if (bitv::get(v, *p.val)) {
       s += "foo";
     }
   }

trunk/src/test/compile-fail/item-name-overload.rs

@@ -4,7 +4,7 @@
 
 mod foo {
   fn bar[T](T f) -> int { ret 17; }
-  type bar[U, T] = tup(int, U, T);
+  type bar[U, T] = rec(int a, U b, T c);
 }
 
 fn main() {}

trunk/src/test/compile-fail/writing-to-immutable-tup.rs

@@ -4,12 +4,11 @@
 // xfail-stage3
 // -*- rust -*-
 
-fn f(chan[int] c)
-{
-  type t = tup(int,int,int);
+fn f(chan[int] c) {
+  type t = rec(int _0, int _1, int _2);
 
   // Allocate a box.
-  let @t x = @tup(1,2,3);
+  let @t x = @rec(_0=1, _1=2, _2=3);
 
   // Signal parent that we've allocated a box.
   c <| 1;

trunk/src/test/run-pass/acyclic-unwind.rs

@@ -2,6 +2,6 @@
 
 
 // -*- rust -*-
-fn f[T, U](&T x, &U y) -> tup(T, U) { ret tup(x, y); }
+fn f[T, U](&T x, &U y) -> rec(T a, U b) { ret rec(a=x, b=y); }
 
-fn main() { log f(tup(3, 4, 5), 4)._0._0; log f(5, 6)._0; }
+fn main() { log f(rec(x=3, y=4, z=5), 4).a.x; log f(5, 6).a; }

trunk/src/test/run-pass/auto-instantiate.rs

@@ -4,17 +4,17 @@
 // -*- rust -*-
 type clam = rec(@int x, @int y);
 
-type fish = tup(@int);
+type fish = rec(@int a);
 
 fn main() {
     let clam a = rec(x=@1, y=@2);
     let clam b = rec(x=@10, y=@20);
     let int z = a.x + b.y;
     log z;
     assert (z == 21);
-    let fish forty = tup(@40);
-    let fish two = tup(@2);
-    let int answer = forty._0 + two._0;
+    let fish forty = rec(a=@40);
+    let fish two = rec(a=@2);
+    let int answer = forty.a + two.a;
     log answer;
     assert (answer == 42);
 }

trunk/src/test/run-pass/autoderef-full-lval.rs

@@ -54,7 +54,7 @@ fn test_char() {
 fn test_box() {
   assert @10 == 10;
   assert 0xFF & @0xF0 == 0xF0;
-  assert tup(1, 3) < @tup(1, 4);
+  assert rec(a=1, b=3) < @rec(a=1, b=4);
   assert @rec(a = 'x') != @rec(a = 'y');
 }
 

trunk/src/test/run-pass/binops.rs

@@ -1,12 +1,12 @@
 
 
-type box[T] = tup(@T);
+type box[T] = rec(@T c);
 
-fn unbox[T](&box[T] b) -> T { ret *b._0; }
+fn unbox[T](&box[T] b) -> T { ret *b.c; }
 
 fn main() {
     let int foo = 17;
-    let box[int] bfoo = tup(@foo);
+    let box[int] bfoo = rec(c=@foo);
     log "see what's in our box";
     assert (unbox[int](bfoo) == foo);
 }

trunk/src/test/run-pass/box-in-tup.rs

@@ -15,12 +15,12 @@ fn test_bool() {
     test_generic[bool](true, eq);
 }
 
-fn test_tup() {
-    type t = tup(int, int);
+fn test_rec() {
+    type t = rec(int a, int b);
 
-    fn compare_tup(&t t1, &t t2) -> bool { ret t1 == t2; }
-    auto eq = bind compare_tup(_, _);
-    test_generic[t](tup(1, 2), eq);
+    fn compare_rec(&t t1, &t t2) -> bool { ret t1 == t2; }
+    auto eq = bind compare_rec(_, _);
+    test_generic[t](rec(a=1, b=2), eq);
 }
 
-fn main() { test_bool(); test_tup(); }
+fn main() { test_bool(); test_rec(); }

trunk/src/test/run-pass/box-unbox.rs

@@ -17,12 +17,12 @@ fn test_bool() {
     test_generic[bool](true, eq);
 }
 
-fn test_tup() {
-    type t = tup(int, int);
+fn test_rec() {
+    type t = rec(int a, int b);
 
-    fn compare_tup(&t t1, &t t2) -> bool { ret t1 == t2; }
-    auto eq = bind compare_tup(_, _);
-    test_generic[t](tup(1, 2), eq);
+    fn compare_rec(&t t1, &t t2) -> bool { ret t1 == t2; }
+    auto eq = bind compare_rec(_, _);
+    test_generic[t](rec(a=1, b=2), eq);
 }
 
-fn main() { test_bool(); test_tup(); }
+fn main() { test_bool(); test_rec(); }

trunk/src/test/run-pass/expr-alt-generic.rs

@@ -5,8 +5,8 @@
 
 // Regression test for issue #377
 fn main() {
-    auto a = { auto b = tup(3); b };
-    assert (a._0 == 3);
+    auto a = { auto b = rec(a=3); b };
+    assert (a.a == 3);
     auto c = { auto d = rec(v=3); d };
     assert (c.v == 3);
 }

trunk/src/test/run-pass/expr-block-generic.rs

@@ -17,12 +17,12 @@ fn test_bool() {
     test_generic[bool](true, false, eq);
 }
 
-fn test_tup() {
-    type t = tup(int, int);
+fn test_rec() {
+    type t = rec(int a, int b);
 
-    fn compare_tup(&t t1, &t t2) -> bool { ret t1 == t2; }
-    auto eq = bind compare_tup(_, _);
-    test_generic[t](tup(1, 2), tup(2, 3), eq);
+    fn compare_rec(&t t1, &t t2) -> bool { ret t1 == t2; }
+    auto eq = bind compare_rec(_, _);
+    test_generic[t](rec(a=1, b=2), rec(a=2, b=3), eq);
 }
 
-fn main() { test_bool(); test_tup(); }
+fn main() { test_bool(); test_rec(); }

trunk/src/test/run-pass/expr-block-slot.rs

@@ -1,9 +1,9 @@
 
 
 obj ob[K](K k) {
-    iter foo() -> @tup(K) { put @tup(k); }
+    iter foo() -> @rec(K a) { put @rec(a=k); }
 }
 
-fn x(&ob[str] o) { for each (@tup(str) i in o.foo()) { } }
+fn x(&ob[str] o) { for each (@rec(str a) i in o.foo()) { } }
 
 fn main() { auto o = ob[str]("hi" + "there"); x(o); }

trunk/src/test/run-pass/expr-if-generic.rs

@@ -1,15 +1,15 @@
 
 
-iter pairs() -> tup(int, int) {
+iter pairs() -> rec(int _0, int _1) {
     let int i = 0;
     let int j = 0;
-    while (i < 10) { put tup(i, j); i += 1; j += i; }
+    while (i < 10) { put rec(_0=i, _1=j); i += 1; j += i; }
 }
 
 fn main() {
     let int i = 10;
     let int j = 0;
-    for each (tup(int, int) p in pairs()) {
+    for each (rec(int _0, int _1) p in pairs()) {
         log p._0;
         log p._1;
         assert (p._0 + 10 == i);

trunk/src/test/run-pass/foreach-box-drop.rs

@@ -3,8 +3,8 @@
 fn id[T](&T t) -> T { ret t; }
 
 fn main() {
-    auto t = tup(1, 2, 3, 4, 5, 6, 7);
-    assert (t._5 == 6);
-    auto f0 = bind id[tup(int, int, int, int, int, int, int)](t);
-    assert (f0()._5 == 6);
+    auto t = rec(a=1, b=2, c=3, d=4, e=5, f=6, g=7);
+    assert (t.f == 6);
+    auto f0 = bind id(t);
+    assert (f0().f == 6);
 }

trunk/src/test/run-pass/foreach-put-structured.rs

@@ -3,8 +3,9 @@
 fn id[T](&T t) -> T { ret t; }
 
 fn main() {
-    auto t = tup(1, 2, 3, 4, 5, 6, 7);
+    auto t = rec(_0=1, _1=2, _2=3, _3=4, _4=5, _5=6, _6=7);
     assert (t._5 == 6);
-    auto f1 = bind id[tup(int, int, int, int, int, int, int)](_);
+    auto f1 = bind id[rec(int _0, int _1, int _2, int _3, int _4,
+                          int _5, int _6)](_);
     assert (f1(t)._5 == 6);
 }

trunk/src/test/run-pass/generic-bind-2.rs

@@ -1,8 +1,8 @@
 
 
-fn box[T](&tup(T, T, T) x) -> @tup(T, T, T) { ret @x; }
+fn box[T](&rec(T x, T y, T z) x) -> @rec(T x, T y, T z) { ret @x; }
 
 fn main() {
-    let @tup(int, int, int) x = box[int](tup(1, 2, 3));
-    assert (x._1 == 2);
+    let @rec(int x, int y, int z) x = box[int](rec(x=1, y=2, z=3));
+    assert (x.y == 2);
 }

trunk/src/test/run-pass/generic-bind.rs

@@ -2,17 +2,17 @@
 
 fn g[X](&X x) -> X { ret x; }
 
-fn f[T](&T t) -> tup(T, T) {
-    type pair = tup(T, T);
+fn f[T](&T t) -> rec(T a, T b) {
+    type pair = rec(T a, T b);
 
-    let pair x = tup(t, t);
+    let pair x = rec(a=t, b=t);
     ret g[pair](x);
 }
 
 fn main() {
     auto b = f[int](10);
-    log b._0;
-    log b._1;
-    assert (b._0 == 10);
-    assert (b._1 == 10);
+    log b.a;
+    log b.b;
+    assert (b.a == 10);
+    assert (b.b == 10);
 }