Lines Matching defs:left
4546 // on the left- and right-hand sides. In particular, Unicode code points
6757 let (left, right) = values.split_at_mut(2);
6759 let left: &[_] = left;
6760 assert!(&left[..left.len()] == &[1, 2]);
6762 for p in left {
6990 let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
6992 assert_eq!((1, 4), (left[0], right[0]));
6993 assert_eq!((2, 5), (left[1], right[1]));
6994 assert_eq!((3, 6), (left[2], right[2]));
10426 let (left, right) = values.split_at_mut(2);
10428 let left: &[_] = left;
10429 assert!(left[..left.len()] == [1, 2]);
10431 for p in left {
12084 let (left, right) = ring.as_slices();
12086 assert_eq!(left, &expected[..]);
12092 let (left, right) = ring.as_slices();
12095 assert_eq!(left, &expected_left[..]);
12112 let (left, right) = ring.as_mut_slices();
12114 assert_eq!(left, &expected[..]);
12120 let (left, right) = ring.as_mut_slices();
12123 assert_eq!(left, &expected_left[..]);
13245 // Make sure format!() arguments are always evaluated in a left-to-right
15106 // only user of this function. It is left in place for the time when that is fixed.
18214 /// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if
20633 // Can just steal the data, all that's left is Weaks
22893 // consumed first, then we must copy whatever is left of the shorter run into the remaining
22908 // The left run is shorter.
22915 let left = &mut hole.start;
22919 while *left < hole.end && right < v_end {
22921 // If equal, prefer the left run to maintain stability.
22923 let to_copy = if is_less(&*right, &**left) {
22926 get_and_increment(left)
22939 let left = &mut hole.dest;
22943 while v < *left && buf < *right {
22947 let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) {
22948 decrement_and_get(left)
23071 let left = runs[r + 1];
23075 &mut v[left.start..right.start + right.len],
23076 left.len,
23081 runs[r] = Run { start: left.start, len: left.len + right.len };
24651 // Can just steal the data, all that's left is Weaks
25931 //! * `[fill]<` - the argument is left-aligned in `width` columns
25936 //! left-aligned. The
29197 /// the left iterator and appends the pair from the right iterator.
29203 pub fn append_from_sorted_iters<I>(&mut self, left: I, right: I, length: &mut usize)
29208 // We prepare to merge `left` and `right` into a sorted sequence in linear time.
29209 let iter = MergeIter(MergeIterInner::new(left, right));
29229 // No space left, go up and push there.
29237 // Found a node with space left, push here.
30806 /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive
30849 /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive
32418 /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive
33940 /// on the left side, which is either in the same leaf node or in an ancestor node.
33993 /// the tree will have been deallocated and there is nothing left to return.
34016 /// on the left side, and the key-value pair in between, which is either
34021 /// the tree will have been deallocated and there is nothing left to return.
34119 /// in between, deallocating any node left behind while leaving the corresponding
34137 /// in between, deallocating any node left behind while leaving the corresponding
35367 drop(ins.left);
35714 // - 6 elements in left leaf child
35726 // - 6 elements in left internal child with 7 grandchildren
35727 // - 42 elements in left child's 7 grandchildren with 6 elements each
37503 let mut left = BTreeMap::new();
37505 left.insert(a.spawn(Panic::Never), ());
37506 left.insert(b.spawn(Panic::InDrop), ()); // first duplicate key, dropped during append
37507 left.insert(c.spawn(Panic::Never), ());
37511 catch_unwind(move || left.append(&mut right)).unwrap_err();
37576 let mut left: BTreeMap<_, _> = pairs.clone().collect();
37577 let right = left.split_off(&1);
37578 left.check();
37580 assert_eq!(left.len(), 1);
37582 assert_eq!(*left.first_key_value().unwrap().0, 0);
37592 let mut left: BTreeMap<_, _> = pairs.clone().collect();
37593 assert_eq!(*left.last_key_value().unwrap().0, last);
37594 let right = left.split_off(&last);
37595 left.check();
37597 assert_eq!(left.len(), MIN_INSERTS_HEIGHT_2 - 1);
37599 assert_eq!(*left.last_key_value().unwrap().0, last - 1);
37810 // the element we were asked to remove. Prefer the left adjacent KV,
38625 /// to the left of the node, one between the two pairs, and one at the right of the node.
38738 /// the keys, values and edges to the left of the split point become the left child;
38752 /// Inserts a new key-value pair between the key-value pairs to the right and left of
38772 /// Inserts a new key-value pair between the key-value pairs to the right and left of
38787 Handle::new_edge(result.left.reborrow_mut(), insert_idx)
38851 Handle::new_edge(result.left.reborrow_mut(), insert_idx)
38864 /// Inserts a new key-value pair between the key-value pairs to the right and left of
38869 /// If the returned result is a `Split`, the `left` field will be the root node.
38884 split = match split.left.ascend() {
38892 return (InsertResult::Split(SplitResult { left: root, ..split }), val_ptr);
39001 /// - The node is truncated to only contain the key-value pairs to the left of
39012 SplitResult { left: self.node, kv, right }
39034 /// left of this handle.
39052 SplitResult { left: self.node, kv, right }
39079 /// the KV immediately to the left or to the right in the parent node.
39083 /// Prefers the left side, to be optimal if the given node is somehow
39084 /// underfull, meaning here only that it has fewer elements than its left
39086 /// merging with the left sibling is faster, since we only need to move
39088 /// more than N elements in front. Stealing from the left sibling is also
39091 /// the left.
39202 /// the left child node and returns the shrunk parent node.
39210 /// the left child node and returns that child node.
39218 /// the left child node and returns the edge handle in that child node
39240 /// Removes a key-value pair from the left child and places it in the key-value storage
39253 /// of the parent, while pushing the old parent key-value pair onto the left child.
39254 /// Returns a handle to the edge in the left child specified by `track_left_edge_idx`,
39288 // Move elements from the left child to the right one.
39298 // Move the left-most stolen pair to the parent.
39309 (ForceResult::Internal(mut left), ForceResult::Internal(mut right)) => {
39315 left.edge_area_mut(new_left_len + 1..old_left_len + 1),
39352 // Move parent's key-value pair to the left child.
39356 // Move elements from the right child to the left one.
39372 (ForceResult::Internal(mut left), ForceResult::Internal(mut right)) => {
39376 left.edge_area_mut(old_left_len + 1..new_left_len + 1),
39382 left.correct_childrens_parent_links(old_left_len + 1..new_left_len + 1);
39484 (ForceResult::Internal(mut left), ForceResult::Internal(mut right)) => {
39486 left.edge_area_mut(new_left_len + 1..old_left_len + 1),
39506 // Altered node in existing tree with elements and edges that belong to the left of `kv`.
39507 pub left: NodeRef<marker::Mut<'a>, K, V, NodeType>,
39516 SplitResult { left: self.left.forget_type(), kv: self.kv, right: self.right.forget_type() }
39522 SplitResult { left: self.left.forget_type(), kv: self.kv, right: self.right.forget_type() }
39596 /// Shifts the elements in a slice `distance` positions to the left.
39649 // picturing the tree growing sideways from its root on the left to its
39862 /// Stocks up the left child, assuming the right child isn't underfull, and
39865 /// Returns the left child.
39882 /// Stocks up the right child, assuming the left child isn't underfull, and
40250 let (left, _) = mid.split_at(head);
40251 (right, left)
42614 // ABCDEFGHIJM...KL - swap until the left edge reaches the temp store
42643 /// Rotates the double-ended queue `mid` places to the left.
42691 /// - Rotates `len() - k` places to the left.
42995 /// Calculate the number of elements left to be read in the buffer
43983 // right block size > free space && left block size > free space
48145 /// shifting all elements after it to the left.
48364 /* How many items were left when `same_bucket` paniced.
48623 /// `[at, len)`. After the call, the original vector will be left containing
50018 // First fill the range left by drain().