bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

auto merge of #9180 : blake2-ppc/rust/reduce-either, r=catamorphism

Browse source 
Work a bit towards #9157 "Remove Either". These instances don't need to use Either and are better expressed in other ways (removing allocations and simplifying types).
This commit is contained in:
bors 2013-09-14 08:50:50 -07:00
commit 1c26513ef9
6 changed files with 58 additions and 66 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/libextra/test.rs
View file

@ -31,7 +31,6 @@ use treemap::TreeMap;
use std::clone::Clone;
use std::comm::{stream, SharedChan, GenericPort, GenericChan};
use std::libc;
use std::either;
use std::io;
use std::result;
use std::task;
@ -127,8 +126,8 @@ pub type MetricDiff = TreeMap<~str,MetricChange>;
pub fn test_main(args: &[~str], tests: ~[TestDescAndFn]) {
let opts =
match parse_opts(args) {
either::Left(o) => o,
either::Right(m) => fail!(m)
Ok(o) => o,
Err(msg) => fail!(msg)
};
if !run_tests_console(&opts, tests) { fail!("Some tests failed"); }
}
@ -169,7 +168,7 @@ pub struct TestOpts {
logfile: Option<Path>
}
type OptRes = Either<TestOpts, ~str>;
type OptRes = Result<TestOpts, ~str>;
fn optgroups() -> ~[getopts::groups::OptGroup] {
~[groups::optflag("", "ignored", "Run ignored tests"),
@ -228,7 +227,7 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
let matches =
match groups::getopts(args_, optgroups()) {
Ok(m) => m,
Err(f) => return either::Right(getopts::fail_str(f))
Err(f) => return Err(getopts::fail_str(f))
};
if getopts::opt_present(&matches, "h") { usage(args[0], "h"); }
@ -274,7 +273,7 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
logfile: logfile
};
either::Left(test_opts)
Ok(test_opts)
}
pub fn opt_shard(maybestr: Option<~str>) -> Option<(uint,uint)> {
@ -1155,7 +1154,6 @@ mod tests {
StaticTestName, DynTestName, DynTestFn};
use test::{TestOpts, run_test};
use std::either;
use std::comm::{stream, SharedChan};
use tempfile;
use std::os;
@ -1236,7 +1234,7 @@ mod tests {
fn first_free_arg_should_be_a_filter() {
let args = ~[~"progname", ~"filter"];
let opts = match parse_opts(args) {
either::Left(o) => o,
Ok(o) => o,
_ => fail!("Malformed arg in first_free_arg_should_be_a_filter")
};
assert!("filter" == opts.filter.clone().unwrap());
@ -1246,7 +1244,7 @@ mod tests {
fn parse_ignored_flag() {
let args = ~[~"progname", ~"filter", ~"--ignored"];
let opts = match parse_opts(args) {
either::Left(o) => o,
Ok(o) => o,
_ => fail!("Malformed arg in parse_ignored_flag")
};
assert!((opts.run_ignored));

32
src/libextra/workcache.rs
View file

@ -19,7 +19,6 @@ use arc::{Arc,RWArc};
use treemap::TreeMap;
use std::cell::Cell;
use std::comm::{PortOne, oneshot};
use std::either::{Either, Left, Right};
use std::{io, os, task};
/**
@ -252,9 +251,9 @@ struct Exec {
discovered_outputs: WorkMap
}
struct Work<'self, T> {
prep: &'self Prep<'self>,
res: Option<Either<T,PortOne<(Exec,T)>>>
enum Work<'self, T> {
WorkValue(T),
WorkFromTask(&'self Prep<'self>, PortOne<(Exec, T)>),
}
fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
@ -426,7 +425,7 @@ impl<'self> Prep<'self> {
db.prepare(self.fn_name, &self.declared_inputs)
};
let res = match cached {
match cached {
Some((ref disc_in, ref disc_out, ref res))
if self.all_fresh("declared input",&self.declared_inputs) &&
self.all_fresh("discovered input", disc_in) &&
@ -434,7 +433,7 @@ impl<'self> Prep<'self> {
debug!("Cache hit!");
debug!("Trying to decode: %? / %? / %?",
disc_in, disc_out, *res);
Left(json_decode(*res))
Work::from_value(json_decode(*res))
}
_ => {
@ -453,10 +452,9 @@ impl<'self> Prep<'self> {
let v = blk(&mut exe);
chan.send((exe, v));
}
Right(port)
Work::from_task(self, port)
}
}
};
Work::new(self, res)
}
}
@ -465,16 +463,18 @@ impl<'self, T:Send +
Decodable<json::Decoder>>
Work<'self, T> { // FIXME(#5121)
pub fn new(p: &'self Prep<'self>, e: Either<T,PortOne<(Exec,T)>>) -> Work<'self, T> {
Work { prep: p, res: Some(e) }
pub fn from_value(elt: T) -> Work<'self, T> {
WorkValue(elt)
}
pub fn from_task(prep: &'self Prep<'self>, port: PortOne<(Exec, T)>)
-> Work<'self, T> {
WorkFromTask(prep, port)
}
pub fn unwrap(self) -> T {
let Work { prep, res } = self;
match res {
None => fail!(),
Some(Left(v)) => v,
Some(Right(port)) => {
match self {
WorkValue(v) => v,
WorkFromTask(prep, port) => {
let (exe, v) = port.recv();
let s = json_encode(&v);
do prep.ctxt.db.write |db| {

7
src/libstd/logging.rs
View file

@ -12,9 +12,8 @@
use option::*;
use os;
use either::*;
use rt;
use rt::logging::{Logger, StdErrLogger};
use rt::logging::{Logger, StdErrLogger, OwnedString};
/// Turns on logging to stdout globally
pub fn console_on() {
@ -57,12 +56,12 @@ fn newsched_log_str(msg: ~str) {
match optional_task {
Some(local) => {
// Use the available logger
(*local).logger.log(Left(msg));
(*local).logger.log(OwnedString(msg));
}
None => {
// There is no logger anywhere, just write to stderr
let mut logger = StdErrLogger;
logger.log(Left(msg));
logger.log(OwnedString(msg));
}
}
}

24
src/libstd/rt/logging.rs
View file

@ -7,7 +7,6 @@
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use either::*;
use libc::{uintptr_t, exit, STDERR_FILENO};
use option::{Some, None, Option};
use rt::util::dumb_println;
@ -168,14 +167,20 @@ fn update_log_settings(crate_map: *u8, settings: ~str) {
}
}
/// Represent a string with `Send` bound.
pub enum SendableString {
OwnedString(~str),
StaticString(&'static str)
}
pub trait Logger {
fn log(&mut self, msg: Either<~str, &'static str>);
fn log(&mut self, msg: SendableString);
}
pub struct StdErrLogger;
impl Logger for StdErrLogger {
fn log(&mut self, msg: Either<~str, &'static str>) {
fn log(&mut self, msg: SendableString) {
use io::{Writer, WriterUtil};
if !should_log_console() {
@ -183,14 +188,11 @@ impl Logger for StdErrLogger {
}
let s: &str = match msg {
Left(ref s) => {
let s: &str = *s;
s
}
Right(ref s) => {
let s: &str = *s;
s
}
OwnedString(ref s) => {
let slc: &str = *s;
slc
},
StaticString(s) => s,
};
// Truncate the string

5
src/libstd/sys.rs
View file

@ -136,12 +136,11 @@ impl FailWithCause for &'static str {
// FIXME #4427: Temporary until rt::rt_fail_ goes away
pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
use either::Left;
use option::{Some, None};
use rt::in_green_task_context;
use rt::task::Task;
use rt::local::Local;
use rt::logging::Logger;
use rt::logging::{Logger, OwnedString};
use str::Str;
unsafe {
@ -164,7 +163,7 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
msg, file, line as int)
};
task.logger.log(Left(msg));
task.logger.log(OwnedString(msg));
}
} else {
rterrln!("failed in non-task context at '%s', %s:%i",

36
src/libsyntax/parse/parser.rs
View file

@ -80,8 +80,6 @@ use parse::{new_sub_parser_from_file, ParseSess};
use opt_vec;
use opt_vec::OptVec;
use std::either::Either;
use std::either;
use std::hashmap::HashSet;
use std::util;
use std::vec;
@ -94,7 +92,6 @@ enum restriction {
RESTRICT_NO_BAR_OR_DOUBLEBAR_OP,
}
type arg_or_capture_item = Either<arg, ()>;
type item_info = (Ident, item_, Option<~[Attribute]>);
/// How to parse a path. There are four different kinds of paths, all of which
@ -936,7 +933,7 @@ impl Parser {
let (explicit_self, d) = do self.parse_fn_decl_with_self() |p| {
// This is somewhat dubious; We don't want to allow argument
// names to be left off if there is a definition...
either::Left(p.parse_arg_general(false))
p.parse_arg_general(false)
};
let hi = p.last_span.hi;
@ -1290,12 +1287,12 @@ impl Parser {
}
// parse a single function argument
pub fn parse_arg(&self) -> arg_or_capture_item {
either::Left(self.parse_arg_general(true))
pub fn parse_arg(&self) -> arg {
self.parse_arg_general(true)
}
// parse an argument in a lambda header e.g. |arg, arg|
pub fn parse_fn_block_arg(&self) -> arg_or_capture_item {
pub fn parse_fn_block_arg(&self) -> arg {
self.parse_arg_mode();
let is_mutbl = self.eat_keyword(keywords::Mut);
let pat = self.parse_pat();
@ -1308,12 +1305,12 @@ impl Parser {
span: mk_sp(self.span.lo, self.span.hi),
}
};
either::Left(ast::arg {
ast::arg {
is_mutbl: is_mutbl,
ty: t,
pat: pat,
id: ast::DUMMY_NODE_ID
})
}
}
pub fn maybe_parse_fixed_vstore(&self) -> Option<@ast::Expr> {
@ -3500,7 +3497,7 @@ impl Parser {
// parse the argument list and result type of a function declaration
pub fn parse_fn_decl(&self) -> fn_decl {
let args_or_capture_items: ~[arg_or_capture_item] =
let args: ~[arg] =
self.parse_unspanned_seq(
&token::LPAREN,
&token::RPAREN,
@ -3508,11 +3505,9 @@ impl Parser {
|p| p.parse_arg()
);
let inputs = either::lefts(args_or_capture_items.move_iter()).collect();
let (ret_style, ret_ty) = self.parse_ret_ty();
ast::fn_decl {
inputs: inputs,
inputs: args,
output: ret_ty,
cf: ret_style,
}
@ -3542,7 +3537,7 @@ impl Parser {
fn parse_fn_decl_with_self(
&self,
parse_arg_fn:
&fn(&Parser) -> arg_or_capture_item
&fn(&Parser) -> arg
) -> (explicit_self, fn_decl) {
fn maybe_parse_explicit_self(
cnstr: &fn(v: Mutability) -> ast::explicit_self_,
@ -3650,20 +3645,20 @@ impl Parser {
};
// If we parsed a self type, expect a comma before the argument list.
let args_or_capture_items;
let fn_inputs;
if explicit_self != sty_static {
match *self.token {
token::COMMA => {
self.bump();
let sep = seq_sep_trailing_disallowed(token::COMMA);
args_or_capture_items = self.parse_seq_to_before_end(
fn_inputs = self.parse_seq_to_before_end(
&token::RPAREN,
sep,
parse_arg_fn
);
}
token::RPAREN => {
args_or_capture_items = ~[];
fn_inputs = ~[];
}
_ => {
self.fatal(
@ -3676,7 +3671,7 @@ impl Parser {
}
} else {
let sep = seq_sep_trailing_disallowed(token::COMMA);
args_or_capture_items = self.parse_seq_to_before_end(
fn_inputs = self.parse_seq_to_before_end(
&token::RPAREN,
sep,
parse_arg_fn
@ -3687,11 +3682,10 @@ impl Parser {
let hi = self.span.hi;
let inputs = either::lefts(args_or_capture_items.move_iter()).collect();
let (ret_style, ret_ty) = self.parse_ret_ty();
let fn_decl = ast::fn_decl {
inputs: inputs,
inputs: fn_inputs,
output: ret_ty,
cf: ret_style
};
@ -3720,7 +3714,7 @@ impl Parser {
};
ast::fn_decl {
inputs: either::lefts(inputs_captures.move_iter()).collect(),
inputs: inputs_captures,
output: output,
cf: return_val,
}