check_lines,
breakpoint_lines
} = parse_debugger_commands(testfile, "gdb");
- let mut cmds = commands.connect("\n");
+ let mut cmds = commands.join("\n");
// compile test file (it should have 'compile-flags:-g' in the header)
let compiler_run_result = compile_test(config, props, testfile);
split_maybe_args(options).into_iter()
.filter(|x| !options_to_remove.contains(x))
.collect::<Vec<String>>()
- .connect(" ");
+ .join(" ");
Some(new_options)
}
// Linux and mac don't require adjusting the library search path
if cfg!(unix) {
- format!("{} {}", prog, args.connect(" "))
+ format!("{} {}", prog, args.join(" "))
} else {
// Build the LD_LIBRARY_PATH variable as it would be seen on the command line
// for diagnostic purposes
format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
}
- format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
+ format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.join(" "))
}
}
assert_eq!(d, [1, 2, 3]);
let v: &[&[_]] = &[&[1], &[2, 3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 3]);
+ assert_eq!(v.join(&0), [1, 0, 2, 3]);
let v: &[&[_]] = &[&[1], &[2], &[3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
+ assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
}
#[test]
-fn test_connect() {
+fn test_join() {
let v: [Vec<i32>; 0] = [];
- assert_eq!(v.connect(&0), []);
- assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
- assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
+ assert_eq!(v.join(&0), []);
+ assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]);
+ assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]);
let v: [&[_]; 2] = [&[1], &[2, 3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 3]);
+ assert_eq!(v.join(&0), [1, 0, 2, 3]);
let v: [&[_]; 3] = [&[1], &[2], &[3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
+ assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
}
#[test]
}
#[bench]
- fn connect(b: &mut Bencher) {
+ fn join(b: &mut Bencher) {
let xss: Vec<Vec<i32>> =
(0..100).map(|i| (0..i).collect()).collect();
b.iter(|| {
- xss.connect(&0)
+ xss.join(&0)
});
}
test_concat!("abc", ["", "a", "bc"]);
}
-macro_rules! test_connect {
+macro_rules! test_join {
($expected: expr, $string: expr, $delim: expr) => {
{
- let s = $string.connect($delim);
+ let s = $string.join($delim);
assert_eq!($expected, s);
}
}
}
#[test]
-fn test_connect_for_different_types() {
- test_connect!("a-b", ["a", "b"], "-");
+fn test_join_for_different_types() {
+ test_join!("a-b", ["a", "b"], "-");
let hyphen = "-".to_string();
- test_connect!("a-b", [s("a"), s("b")], &*hyphen);
- test_connect!("a-b", vec!["a", "b"], &*hyphen);
- test_connect!("a-b", &*vec!["a", "b"], "-");
- test_connect!("a-b", vec![s("a"), s("b")], "-");
+ test_join!("a-b", [s("a"), s("b")], &*hyphen);
+ test_join!("a-b", vec!["a", "b"], &*hyphen);
+ test_join!("a-b", &*vec!["a", "b"], "-");
+ test_join!("a-b", vec![s("a"), s("b")], "-");
}
#[test]
-fn test_connect_for_different_lengths() {
+fn test_join_for_different_lengths() {
let empty: &[&str] = &[];
- test_connect!("", empty, "-");
- test_connect!("a", ["a"], "-");
- test_connect!("a-b", ["a", "b"], "-");
- test_connect!("-a-bc", ["", "a", "bc"], "-");
+ test_join!("", empty, "-");
+ test_join!("a", ["a"], "-");
+ test_join!("a-b", ["a", "b"], "-");
+ test_join!("-a-bc", ["", "a", "bc"], "-");
}
#[test]
}
#[bench]
- fn bench_connect(b: &mut Bencher) {
+ fn bench_join(b: &mut Bencher) {
let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
let sep = "→";
let v = vec![s, s, s, s, s, s, s, s, s, s];
b.iter(|| {
- assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9);
+ assert_eq!(v.join(sep).len(), s.len() * 10 + sep.len() * 9);
})
}
// FIXME: #5516 should be graphemes not codepoints
// wrapped description
- row.push_str(&desc_rows.connect(&desc_sep[..]));
+ row.push_str(&desc_rows.join(&desc_sep[..]));
row
});
format!("{}\n\nOptions:\n{}\n", brief,
- rows.collect::<Vec<String>>().connect("\n"))
+ rows.collect::<Vec<String>>().join("\n"))
}
fn format_option(opt: &OptGroup) -> String {
line.push_str(&opts.iter()
.map(format_option)
.collect::<Vec<String>>()
- .connect(" ")[..]);
+ .join(" ")[..]);
line
}
cstore::RequireStatic => "s",
})).to_string())
}).collect::<Vec<String>>();
- rbml_w.wr_tagged_str(tag, &s.connect(","));
+ rbml_w.wr_tagged_str(tag, &s.join(","));
}
None => {
rbml_w.wr_tagged_str(tag, "");
pub fn tys_to_string(&self, ts: &[Ty<'tcx>]) -> String {
let tstrs: Vec<String> = ts.iter().map(|t| self.ty_to_string(*t)).collect();
- format!("({})", tstrs.connect(", "))
+ format!("({})", tstrs.join(", "))
}
pub fn trait_ref_to_string(&self, t: &ty::TraitRef<'tcx>) -> String {
let mut file = try!(fs::File::create(&deps_filename));
for path in &out_filenames {
try!(write!(&mut file,
- "{}: {}\n\n", path.display(), files.connect(" ")));
+ "{}: {}\n\n", path.display(), files.join(" ")));
}
Ok(())
})();
for (name, to) in lints {
let name = name.to_lowercase().replace("_", "-");
let desc = to.into_iter().map(|x| x.as_str().replace("_", "-"))
- .collect::<Vec<String>>().connect(", ");
+ .collect::<Vec<String>>().join(", ");
println!(" {} {}",
padded(&name[..]), desc);
}
fn reconstructed_input(&self) -> String {
match *self {
ItemViaNode(node_id) => node_id.to_string(),
- ItemViaPath(ref parts) => parts.connect("::"),
+ ItemViaPath(ref parts) => parts.join("::"),
}
}
return match search_mod(self, &self.infcx.tcx.map.krate().module, 0, names) {
Some(id) => id,
None => {
- panic!("no item found: `{}`", names.connect("::"));
+ panic!("no item found: `{}`", names.join("::"));
}
};
}
words.push(buf);
}
- words.connect("_")
+ words.join("_")
}
fn check_snake_case(&self, cx: &Context, sort: &str, name: &str, span: Option<Span>) {
bcx.to_str(),
guard_expr,
m,
- vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().connect(", "));
+ vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().join(", "));
let _indenter = indenter();
let mut bcx = insert_lllocals(bcx, &data.bindings_map, None);
debug!("compile_submatch(bcx={}, m={:?}, vals=[{}])",
bcx.to_str(),
m,
- vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().connect(", "));
+ vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().join(", "));
let _indenter = indenter();
let _icx = push_ctxt("match::compile_submatch");
let mut bcx = bcx;
.chain(arch_clobbers.iter()
.map(|s| s.to_string()))
.collect::<Vec<String>>()
- .connect(",");
+ .join(",");
debug!("Asm Constraints: {}", &all_constraints[..]);
terminate(cx, "Invoke");
debug!("Invoke({} with arguments ({}))",
cx.val_to_string(fn_),
- args.iter().map(|a| cx.val_to_string(*a)).collect::<Vec<String>>().connect(", "));
+ args.iter().map(|a| cx.val_to_string(*a)).collect::<Vec<String>>().join(", "));
debug_loc.apply(cx.fcx);
B(cx).invoke(fn_, args, then, catch, attributes)
}
args.iter()
.map(|&v| self.ccx.tn().val_to_string(v))
.collect::<Vec<String>>()
- .connect(", "));
+ .join(", "));
unsafe {
let v = llvm::LLVMBuildInvoke(self.llbuilder,
args.iter()
.map(|&v| self.ccx.tn().val_to_string(v))
.collect::<Vec<String>>()
- .connect(", "));
+ .join(", "));
unsafe {
let v = llvm::LLVMBuildCall(self.llbuilder, llfn, args.as_ptr(),
let discrfield = discrfield.iter()
.skip(1)
.map(|x| x.to_string())
- .collect::<Vec<_>>().connect("$");
+ .collect::<Vec<_>>().join("$");
let union_member_name = format!("RUST$ENCODED$ENUM${}${}",
discrfield,
null_variant_name);
impl<T:LlvmRepr> LlvmRepr for [T] {
fn llrepr(&self, ccx: &CrateContext) -> String {
let reprs: Vec<String> = self.iter().map(|t| t.llrepr(ccx)).collect();
- format!("[{}]", reprs.connect(","))
+ format!("[{}]", reprs.join(","))
}
}
pub fn types_to_str(&self, tys: &[Type]) -> String {
let strs: Vec<String> = tys.iter().map(|t| self.type_to_string(*t)).collect();
- format!("[{}]", strs.connect(","))
+ format!("[{}]", strs.join(","))
}
pub fn val_to_string(&self, val: ValueRef) -> String {
let tstr = if strings.is_empty() {
base
} else {
- format!("{}<{}>", base, strings.connect(", "))
+ format!("{}<{}>", base, strings.join(", "))
};
if did.krate == 0 {
p.self_ty(),
p))
.collect::<Vec<_>>()
- .connect(", ");
+ .join(", ");
cx.sess.fileline_note(
span,
&format!("the method `{}` exists but the \
"not all trait items implemented, missing: `{}`",
missing_items.iter()
.map(<ast::Name>::as_str)
- .collect::<Vec<_>>().connect("`, `"))
+ .collect::<Vec<_>>().join("`, `"))
}
if !invalidated_items.is_empty() {
invalidator.ident.as_str(),
invalidated_items.iter()
.map(<ast::Name>::as_str)
- .collect::<Vec<_>>().connect("`, `"))
+ .collect::<Vec<_>>().join("`, `"))
}
}
span_err!(tcx.sess, span, E0063,
"missing field{}: {}",
if missing_fields.len() == 1 {""} else {"s"},
- missing_fields.connect(", "));
+ missing_fields.join(", "));
}
}
} else {
name.to_string()
}, a, b)
- }).collect::<Vec<_>>().connect(", "));
+ }).collect::<Vec<_>>().join(", "));
return;
}
d => format!("{:?}", d),
})
.collect::<Vec<String>>()
- .connect(",");
+ .join(",");
tcx.sess.span_err(it.span, &object_lifetime_default_reprs);
}
format!("{} {{ {}{} }}", path_to_string(name),
fields.iter().map(|&Spanned { node: ref fp, .. }|
format!("{}: {}", fp.ident.as_str(), name_from_pat(&*fp.pat)))
- .collect::<Vec<String>>().connect(", "),
+ .collect::<Vec<String>>().join(", "),
if etc { ", ..." } else { "" }
)
},
PatTup(ref elts) => format!("({})", elts.iter().map(|p| name_from_pat(&**p))
- .collect::<Vec<String>>().connect(", ")),
+ .collect::<Vec<String>>().join(", ")),
PatBox(ref p) => name_from_pat(&**p),
PatRegion(ref p, _) => name_from_pat(&**p),
PatLit(..) => {
let begin = begin.iter().map(|p| name_from_pat(&**p));
let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(&**p))).into_iter();
let end = end.iter().map(|p| name_from_pat(&**p));
- format!("[{}]", begin.chain(mid).chain(end).collect::<Vec<_>>().connect(", "))
+ format!("[{}]", begin.chain(mid).chain(end).collect::<Vec<_>>().join(", "))
},
PatMac(..) => {
warn!("can't document the name of a function argument \
match href(did) {
Some((url, shortty, fqp)) => {
try!(write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
- shortty, url, fqp.connect("::"), last.name));
+ shortty, url, fqp.join("::"), last.name));
}
_ => try!(write!(w, "{}", last.name)),
}
fn collapse_whitespace(s: &str) -> String {
s.split(|c: char| c.is_whitespace()).filter(|s| {
!s.is_empty()
- }).collect::<Vec<_>>().connect(" ")
+ }).collect::<Vec<_>>().join(" ")
}
thread_local!(static USED_HEADER_MAP: RefCell<HashMap<String, usize>> = {
let lines = origtext.lines().filter(|l| {
stripped_filtered_line(*l).is_none()
});
- let text = lines.collect::<Vec<&str>>().connect("\n");
+ let text = lines.collect::<Vec<&str>>().join("\n");
if rendered { return }
PLAYGROUND_KRATE.with(|krate| {
let mut s = String::new();
krate.borrow().as_ref().map(|krate| {
let test = origtext.lines().map(|l| {
stripped_filtered_line(l).unwrap_or(l)
- }).collect::<Vec<&str>>().connect("\n");
+ }).collect::<Vec<&str>>().join("\n");
let krate = krate.as_ref().map(|s| &**s);
let test = test::maketest(&test, krate, false,
&Default::default());
// Transform the contents of the header into a hyphenated string
let id = s.split_whitespace().map(|s| s.to_ascii_lowercase())
- .collect::<Vec<String>>().connect("-");
+ .collect::<Vec<String>>().join("-");
// This is a terrible hack working around how hoedown gives us rendered
// html for text rather than the raw text.
let lines = text.lines().map(|l| {
stripped_filtered_line(l).unwrap_or(l)
});
- let text = lines.collect::<Vec<&str>>().connect("\n");
+ let text = lines.collect::<Vec<&str>>().join("\n");
tests.add_test(text.to_string(),
block_info.should_panic, block_info.no_run,
block_info.ignore, block_info.test_harness);
let inputs: Vec<String> = self.inputs.iter().map(|ref t| {
format!("{}", t)
}).collect();
- try!(write!(f, "{{\"inputs\":[{}],\"output\":", inputs.connect(",")));
+ try!(write!(f, "{{\"inputs\":[{}],\"output\":", inputs.join(",")));
match self.output {
Some(ref t) => try!(write!(f, "{}", t)),
search_index.push(IndexItem {
ty: shortty(item),
name: item.name.clone().unwrap(),
- path: fqp[..fqp.len() - 1].connect("::"),
+ path: fqp[..fqp.len() - 1].join("::"),
desc: shorter(item.doc_value()),
parent: Some(did),
search_type: get_index_search_type(&item, parent_basename),
self.search_index.push(IndexItem {
ty: shortty(&item),
name: s.to_string(),
- path: path.connect("::").to_string(),
+ path: path.join("::").to_string(),
desc: shorter(item.doc_value()),
parent: parent,
search_type: get_index_search_type(&item, parent_basename),
*slot.borrow_mut() = cx.current.clone();
});
- let mut title = cx.current.connect("::");
+ let mut title = cx.current.join("::");
if pushname {
if !title.is_empty() {
title.push_str("::");
Some(format!("{root}src/{krate}/{path}.html#{href}",
root = self.cx.root_path,
krate = self.cx.layout.krate,
- path = path.connect("/"),
+ path = path.join("/"),
href = href))
// If this item is not part of the local crate, then things get a little
};
Some(format!("{root}{path}/{file}?gotosrc={goto}",
root = root,
- path = path[..path.len() - 1].connect("/"),
+ path = path[..path.len() - 1].join("/"),
file = item_path(self.item),
goto = self.item.def_id.node))
}
}
fn full_path(cx: &Context, item: &clean::Item) -> String {
- let mut s = cx.current.connect("::");
+ let mut s = cx.current.join("::");
s.push_str("::");
s.push_str(item.name.as_ref().unwrap());
return s
(*line).chars().any(|chr|{
!chr.is_whitespace()
})
- }).collect::<Vec<_>>().connect("\n"),
+ }).collect::<Vec<_>>().join("\n"),
None => "".to_string()
}
}
try!(write!(w, r#"<script type="text/javascript" async
src="{root_path}/implementors/{path}/{ty}.{name}.js">
</script>"#,
- root_path = vec![".."; cx.current.len()].connect("/"),
+ root_path = vec![".."; cx.current.len()].join("/"),
path = if ast_util::is_local(it.def_id) {
- cx.current.connect("/")
+ cx.current.join("/")
} else {
let path = &cache.external_paths[&it.def_id];
- path[..path.len() - 1].connect("/")
+ path[..path.len() - 1].join("/")
},
ty = shortty(it).to_static_str(),
name = *it.name.as_ref().unwrap()));
line[min_indent..].to_string()
}
}).collect::<Vec<_>>());
- unindented.connect("\n")
+ unindented.join("\n")
} else {
s.to_string()
}
let s = self.current_header.as_ref().map(|s| &**s).unwrap_or("");
format!("{}_{}", s, self.cnt)
} else {
- format!("{}_{}", self.names.connect("::"), self.cnt)
+ format!("{}_{}", self.names.join("::"), self.cnt)
};
self.cnt += 1;
let libs = self.libs.clone();
.iter()
.map(|&seg| format!("{:x}", seg))
.collect::<Vec<String>>()
- .connect(":")
+ .join(":")
}
write!(fmt, "{}::{}",
// FIXME: Bad copies (#2543 -- same for everything else that says "bad")
idents.iter().map(|i| {
token::get_ident(*i).to_string()
- }).collect::<Vec<String>>().connect("::")
+ }).collect::<Vec<String>>().join("::")
}
pub fn local_def(id: NodeId) -> DefId {
.iter()
.map(|x| token::get_ident(*x).to_string())
.collect::<Vec<String>>()
- .connect("::");
+ .join("::");
base::MacEager::expr(cx.expr_str(
sp,
token::intern_and_get_ident(&string[..])))
token::get_ident(bind))).to_string()
}
_ => panic!()
- } }).collect::<Vec<String>>().connect(" or ");
+ } }).collect::<Vec<String>>().join(" or ");
return Error(sp, format!(
"local ambiguity: multiple parsing options: \
built-in NTs {} or {} other options.",
let lines = vertical_trim(lines);
let lines = horizontal_trim(lines);
- return lines.connect("\n");
+ return lines.join("\n");
}
panic!("not a doc-comment: {}", comment);
last_span,
&format!("illegal ABI: expected one of [{}], \
found `{}`",
- abi::all_names().connect(", "),
+ abi::all_names().join(", "),
the_string));
Ok(None)
}
.map(|(k,v)| format!("{}: {} (+/- {})", *k,
v.value, v.noise))
.collect();
- v.connect(", ")
+ v.join(", ")
}
}
sp: Span,
_: &[ast::TokenTree]) -> Box<MacResult+'cx> {
let args = self.args.iter().map(|i| pprust::meta_item_to_string(&*i))
- .collect::<Vec<_>>().connect(", ");
+ .collect::<Vec<_>>().join(", ");
let interned = token::intern_and_get_ident(&args[..]);
MacEager::expr(ecx.expr_str(sp, interned))
}
.collect::<Vec<String>>();
// Concatenate the lines together using a new-line.
- write!(f, "{}", lines.connect("\n"))
+ write!(f, "{}", lines.join("\n"))
}
}
self.iter()
.map(|e| e.to_string_())
.collect::<Vec<String>>()
- .connect(", "))
+ .join(", "))
}
}