Lines Matching defs:split
148 b.iter(|| assert_eq!(s.split('V').count(), 3));
154 let len = s.split(' ').count();
156 b.iter(|| assert_eq!(s.split(' ').count(), len));
162 let len = s.split(' ').count();
167 b.iter(|| assert_eq!(s.split(pred).count(), len));
173 let len = s.split(' ').count();
175 b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
181 let len = s.split(' ').count();
184 b.iter(|| assert_eq!(s.split(c).count(), len));
348 make_test!(split_a_str, s, s.split("a").count());
369 make_test!(split_space_char, s, s.split(' ').count());
375 make_test!(split_space_str, s, s.split(" ").count());
376 make_test!(split_ad_str, s, s.split("ad").count());
4777 let split: Vec<&str> = data.splitn(4, ' ').collect();
4778 assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
4780 let split: Vec<&str> = data.splitn(4, |c: char| c == ' ').collect();
4781 assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
4784 let split: Vec<&str> = data.splitn(4, 'ä').collect();
4785 assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
4787 let split: Vec<&str> = data.splitn(4, |c: char| c == 'ä').collect();
4788 assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
4795 let split: Vec<&str> = data.split('\n').collect();
4796 assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
4798 let split: Vec<&str> = data.split_terminator('\n').collect();
4799 assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
4806 let split: Vec<&str> = data.split_inclusive('\n').collect();
4807 assert_eq!(split, ["\n", "Märy häd ä little lämb\n", "Little lämb\n"]);
4811 let split: Vec<&str> = uppercase_separated
4813 let split = !first_char && c.is_uppercase();
4814 first_char = split;
4815 split
4818 assert_eq!(split, ["SheeP", "SharK", "TurtlE", "CaT"]);
4825 let split: Vec<&str> = data.split_inclusive('\n').rev().collect();
4826 assert_eq!(split, ["Little lämb\n", "Märy häd ä little lämb\n", "\n"]);
4834 let split: Vec<&str> = uppercase_separated
4836 let split = term_char && c.is_uppercase();
4838 split
4842 assert_eq!(split, ["CaT", "TurtlE", "SharK", "SheeP"]);
4849 let split: Vec<&str> = data.rsplit(' ').collect();
4850 assert_eq!(split, ["lämb\n", "lämb\nLittle", "little", "ä", "häd", "\nMäry"]);
4852 let split: Vec<&str> = data.rsplit("lämb").collect();
4853 assert_eq!(split, ["\n", "\nLittle ", "\nMäry häd ä little "]);
4855 let split: Vec<&str> = data.rsplit(|c: char| c == 'ä').collect();
4856 assert_eq!(split, ["mb\n", "mb\nLittle l", " little l", "d ", "ry h", "\nM"]);
4863 let split: Vec<&str> = data.rsplitn(2, ' ').collect();
4864 assert_eq!(split, ["lämb\n", "\nMäry häd ä little lämb\nLittle"]);
4866 let split: Vec<&str> = data.rsplitn(2, "lämb").collect();
4867 assert_eq!(split, ["\n", "\nMäry häd ä little lämb\nLittle "]);
4869 let split: Vec<&str> = data.rsplitn(2, |c: char| c == 'ä').collect();
4870 assert_eq!(split, ["mb\n", "\nMäry häd ä little lämb\nLittle l"]);
4918 let v: Vec<&str> = s.split(sep).collect();
5033 let mut split: Vec<&str> = data.rsplitn(4, ' ').collect();
5034 split.reverse();
5035 assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
5037 let mut split: Vec<&str> = data.rsplitn(4, |c: char| c == ' ').collect();
5038 split.reverse();
5039 assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
5042 let mut split: Vec<&str> = data.rsplitn(4, 'ä').collect();
5043 split.reverse();
5044 assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
5046 let mut split: Vec<&str> = data.rsplitn(4, |c: char| c == 'ä').collect();
5047 split.reverse();
5048 assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
5055 let split: Vec<&str> = data.split(' ').collect();
5056 assert_eq!(split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
5058 let mut rsplit: Vec<&str> = data.split(' ').rev().collect();
5062 let split: Vec<&str> = data.split(|c: char| c == ' ').collect();
5063 assert_eq!(split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
5065 let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect();
5070 let split: Vec<&str> = data.split('ä').collect();
5071 assert_eq!(split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
5073 let mut rsplit: Vec<&str> = data.split('ä').rev().collect();
5077 let split: Vec<&str> = data.split(|c: char| c == 'ä').collect();
5078 assert_eq!(split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
5080 let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect();
5089 let mut split: Vec<&str> = data.split('\n').rev().collect();
5090 split.reverse();
5091 assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
5093 let mut split: Vec<&str> = data.split_terminator('\n').rev().collect();
5094 split.reverse();
5095 assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
5423 with str::split, str::rsplit;
5877 let mut split = String::from(orig);
5878 let empty: String = split.split_off(orig.len());
5886 let mut split = String::from(orig);
5887 let _ = split.split_off(orig.len() + 1);
10080 assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
10082 assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits);
10084 assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits);
10086 assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits);
10088 assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits);
10092 assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
10212 assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
10214 assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
10216 assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
10218 assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
10222 assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
22041 //! * Further methods that return iterators are [`.split`], [`.splitn`],
22047 //! [`.split`]: slice::split
22500 // If `n` is larger than zero, it can be split as
27240 // The split node is the new head node of the second part
27279 // The split node is the new tail node of the first part and owns
27797 /// let mut split = d.split_off(2);
27799 /// assert_eq!(split.pop_front(), Some(1));
27800 /// assert_eq!(split.pop_front(), None);
27805 assert!(at <= len, "Cannot split off at a nonexistent index");
34274 mod split;
37571 // In a tree with 3 levels, if all but a part of the first leaf node is split off,
37586 // In a tree with 3 levels, if only part of the last leaf node is split off,
38736 /// computes a sensible KV index of a split point and where to perform the insertion.
38737 /// The goal of the split point is for its key and value to end up in a parent node;
38738 /// the keys, values and edges to the left of the split point become the left child;
38739 /// the keys, values and edges to the right of the split point become the right child.
38784 let mut result = middle.split();
38848 let mut result = middle.split();
38866 /// insert the split off portion into the parent node recursively, until the root is reached.
38876 let (mut split, val_ptr) = match self.insert(key, value) {
38880 (InsertResult::Split(split), val_ptr) => (split.forget_node_type(), val_ptr),
38884 split = match split.left.ascend() {
38885 Ok(parent) => match parent.insert(split.kv.0, split.kv.1, split.right) {
38889 InsertResult::Split(split) => split.forget_node_type(),
38892 return (InsertResult::Split(SplitResult { left: root, ..split }), val_ptr);
38972 /// Helps implementations of `split` for a particular `NodeType`,
39006 pub fn split(mut self) -> SplitResult<'a, K, V, marker::Leaf> {
39038 pub fn split(mut self) -> SplitResult<'a, K, V, marker::Internal> {
39508 // Some key and value split off, to be inserted elsewhere.
39678 // Simulate performing the split:
43871 // split position is tested. Capacity 15 should be large enough to cover every case.
43882 // index to split at
48648 panic!("`at` split index (is {}) should be <= len (is {})", at, len);