Remove all uses of tuples from the compiler and stdlib

4 files changed, 23 insertions, 23 deletions

diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
index bdd0421cb23..ac970c64961 100644
--- a/src/comp/syntax/ext/base.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -8,8 +8,9 @@ import codemap;
 
 type syntax_expander =
     fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> @ast::expr;
+type macro_def = rec(str ident, syntax_extension ext);
 type macro_definer = fn(&ext_ctxt, span, &(@ast::expr)[],
-                        option::t[str]) -> tup(str, syntax_extension);
+                        option::t[str]) -> macro_def;
 
 tag syntax_extension {
     normal(syntax_expander);
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index cb93a4bf45c..3cff1cba5e2 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -38,8 +38,8 @@ fn expand_expr(&hashmap[str, base::syntax_extension] exts,
                         case (some(base::macro_defining(?ext))) {
                             auto named_extension
                                 = ext(ext_cx, pth.span, args, body);
-                            exts.insert(named_extension._0,
-                                        named_extension._1);
+                            exts.insert(named_extension.ident,
+                                        named_extension.ext);
                             ast::expr_tup(~[])
                         }
                     }
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 4aae16f01ce..b69b27f5ef4 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -80,11 +80,12 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
         ret @rec(id=cx.next_id(), node=callexpr, span=sp);
     }
     fn make_rec_expr(&ext_ctxt cx, span sp,
-                     vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr {
+                     vec[rec(ast::ident ident, @ast::expr ex)] fields)
+        -> @ast::expr {
         let ast::field[] astfields = ~[];
-        for (tup(ast::ident, @ast::expr) field in fields) {
-            auto ident = field._0;
-            auto val = field._1;
+        for (rec(ast::ident ident, @ast::expr ex) field in fields) {
+            auto ident = field.ident;
+            auto val = field.ex;
             auto astfield =
                 rec(node=rec(mut=ast::imm, ident=ident, expr=val), span=sp);
             astfields += ~[astfield];
@@ -173,10 +174,10 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces,
                          @ast::expr width_expr, @ast::expr precision_expr,
                          @ast::expr ty_expr) -> @ast::expr {
             ret make_rec_expr(cx, sp,
-                              [tup("flags", flags_expr),
-                               tup("width", width_expr),
-                               tup("precision", precision_expr),
-                               tup("ty", ty_expr)]);
+                              [rec(ident="flags", ex=flags_expr),
+                               rec(ident="width", ex=width_expr),
+                               rec(ident="precision", ex=precision_expr),
+                               rec(ident="ty", ex=ty_expr)]);
         }
         auto rt_conv_flags = make_flags(cx, sp, cnv.flags);
         auto rt_conv_width = make_count(cx, sp, cnv.width);
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index 839cf154d75..95cbb069c25 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -191,10 +191,11 @@ selectors. */
 fn use_selectors_to_bind(&binders b, @expr e) -> option::t[bindings] {
     auto res = new_str_hash[arb_depth[matchable]]();
     let bool never_mind = false;
-    for each(@tup(ident, selector) pair in b.real_binders.items()) {
-        alt (pair._1(match_expr(e))) {
+    for each(@rec(ident key, selector val) pair
+             in b.real_binders.items()) {
+        alt (pair.val(match_expr(e))) {
           case (none) { never_mind = true; }
-          case (some(?mtc)) { res.insert(pair._0, mtc); }
+          case (some(?mtc)) { res.insert(pair.key, mtc); }
         }
     }
     if (never_mind) { ret none; } //HACK: `ret` doesn't work in `for each`
@@ -274,9 +275,7 @@ iter free_vars(&bindings b, @expr e) -> ident {
     auto f = make_fold(f_pre);
     f.fold_expr(e); // ignore result
     dummy_out(f);
-    for each(@tup(ast::ident, ()) it in idents.items()) {
-        put it._0;
-    }
+    for each(ident id in idents.keys()) { put id; }
 }
 
 
@@ -546,7 +545,7 @@ fn p_t_s_r_actual_vector(&ext_ctxt cx, (@expr)[] elts, &selector s,
 }
 
 fn add_new_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
-                     option::t[str] body) -> tup(str, syntax_extension) {
+                     option::t[str] body) -> base::macro_def {
     let option::t[str] macro_name = none;
     let (clause)[] clauses = ~[];
     for (@expr arg in args) {
@@ -596,14 +595,13 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
 
     auto ext = bind generic_extension(_,_,_,_,clauses);
 
-    ret tup(alt (macro_name) {
+    ret rec(ident=alt (macro_name) {
       case (some(?id)) { id }
       case (none) {
         cx.span_fatal(sp, "macro definition must have "
                       + "at least one clause")
       }
-    },
-            normal(ext));
+    }, ext=normal(ext));
 
 
     fn generic_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
@@ -620,9 +618,9 @@ fn add_new_extension(&ext_ctxt cx, span sp, &(@expr)[] args,
                 alt (use_selectors_to_bind(c.params.(i), args.(i))) {
                   case (some(?new_bindings)) {
                     /* ick; I wish macros just took one expr */
-                    for each (@tup(ident,arb_depth[matchable]) it
+                    for each (@rec(ident key, arb_depth[matchable] val) it
                               in new_bindings.items()) {
-                        bdgs.insert(it._0, it._1);
+                        bdgs.insert(it.key, it.val);
                     }
                   }
                   case (none) { abort = true; }