Remove std::either

src/libextra/test.rs

@@ -337,9 +337,14 @@ pub enum TestResult {
     TrBench(BenchSamples),
 }
 
+enum OutputLocation<T> {
+    Pretty(term::Terminal<T>),
+    Raw(T),
+}
+
 struct ConsoleTestState<T> {
     log_out: Option<File>,
-    out: Either<term::Terminal<T>, T>,
+    out: OutputLocation<T>,
     use_color: bool,
     total: uint,
     passed: uint,
@@ -358,8 +363,8 @@ impl<T: Writer> ConsoleTestState<T> {
             None => None
         };
         let out = match term::Terminal::new(io::stdout()) {
-            Err(_) => Right(io::stdout()),
-            Ok(t) => Left(t)
+            Err(_) => Raw(io::stdout()),
+            Ok(t) => Pretty(t)
         };
         ConsoleTestState {
             out: out,
@@ -416,7 +421,7 @@ impl<T: Writer> ConsoleTestState<T> {
                         word: &str,
                         color: term::color::Color) {
         match self.out {
-            Left(ref mut term) => {
+            Pretty(ref mut term) => {
                 if self.use_color {
                     term.fg(color);
                 }
@@ -425,14 +430,14 @@ impl<T: Writer> ConsoleTestState<T> {
                     term.reset();
                 }
             }
-            Right(ref mut stdout) => stdout.write(word.as_bytes())
+            Raw(ref mut stdout) => stdout.write(word.as_bytes())
         }
     }
 
     pub fn write_plain(&mut self, s: &str) {
         match self.out {
-            Left(ref mut term) => term.write(s.as_bytes()),
-            Right(ref mut stdout) => stdout.write(s.as_bytes())
+            Pretty(ref mut term) => term.write(s.as_bytes()),
+            Raw(ref mut stdout) => stdout.write(s.as_bytes())
         }
     }
 
@@ -683,7 +688,7 @@ fn should_sort_failures_before_printing_them() {
 
     let mut st = ConsoleTestState {
         log_out: None,
-        out: Right(MemWriter::new()),
+        out: Raw(MemWriter::new()),
         use_color: false,
         total: 0u,
         passed: 0u,
@@ -697,8 +702,8 @@ fn should_sort_failures_before_printing_them() {
 
     st.write_failures();
     let s = match st.out {
-        Right(ref m) => str::from_utf8(*m.inner_ref()),
-        Left(_) => unreachable!()
+        Raw(ref m) => str::from_utf8(*m.inner_ref()),
+        Pretty(_) => unreachable!()
     };
 
     let apos = s.find_str("a").unwrap();

src/librustc/middle/typeck/check/mod.rs

@@ -1705,9 +1705,12 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                 fn_inputs.map(|a| *a)
             } else {
                 let msg = format!(
-                    "this function takes at least {0, plural, =1{# parameter} \
-                    other{# parameters}} but {1, plural, =1{# parameter was} \
-                    other{# parameters were}} supplied", expected_arg_count, supplied_arg_count);
+                    "this function takes at least {} parameter{} \
+                     but {} parameter{} supplied",
+                     expected_arg_count,
+                     if expected_arg_count == 1 {""} else {"s"},
+                     supplied_arg_count,
+                     if supplied_arg_count == 1 {" was"} else {"s were"});
 
                 tcx.sess.span_err(sp, msg);
 
@@ -1722,10 +1725,12 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                                   the `for` keyword)"
             };
             let msg = format!(
-                "this function takes {0, plural, =1{# parameter} \
-                other{# parameters}} but {1, plural, =1{# parameter was} \
-                other{# parameters were}} supplied{2}",
-                expected_arg_count, supplied_arg_count, suffix);
+                "this function takes {} parameter{} \
+                 but {} parameter{} supplied{}",
+                 expected_arg_count, if expected_arg_count == 1 {""} else {"s"},
+                 supplied_arg_count,
+                 if supplied_arg_count == 1 {" was"} else {"s were"},
+                 suffix);
 
             tcx.sess.span_err(sp, msg);
 

src/libstd/fmt/mod.rs

@@ -757,7 +757,7 @@ impl<'a> Formatter<'a> {
                 // offsetted value
                 for s in selectors.iter() {
                     match s.selector {
-                        Right(val) if value == val => {
+                        rt::Literal(val) if value == val => {
                             return self.runplural(value, s.result);
                         }
                         _ => {}
@@ -769,17 +769,17 @@ impl<'a> Formatter<'a> {
                 let value = value - match offset { Some(i) => i, None => 0 };
                 for s in selectors.iter() {
                     let run = match s.selector {
-                        Left(parse::Zero) => value == 0,
-                        Left(parse::One) => value == 1,
-                        Left(parse::Two) => value == 2,
+                        rt::Keyword(parse::Zero) => value == 0,
+                        rt::Keyword(parse::One) => value == 1,
+                        rt::Keyword(parse::Two) => value == 2,
 
                         // XXX: Few/Many should have a user-specified boundary
                         //      One possible option would be in the function
                         //      pointer of the 'arg: Argument' struct.
-                        Left(parse::Few) => value < 8,
-                        Left(parse::Many) => value >= 8,
+                        rt::Keyword(parse::Few) => value < 8,
+                        rt::Keyword(parse::Many) => value >= 8,
 
-                        Right(..) => false
+                        rt::Literal(..) => false
                     };
                     if run {
                         return self.runplural(value, s.result);