Lines Matching defs:result
1177 let mut result = Vec::with_capacity(data.len());
1180 *result.get_unchecked_mut(i) = data[i].0;
1181 result.set_len(i);
1184 result
4119 // note: using 0 specifically ensures that the result of overflowing is 0..0,
10573 let result = [0, 0, 0, 1, 1, 1, 2];
10574 assert_eq!(v, result);
10585 let result = [2, 2, 2, 1, 1, 1, 0];
10586 assert_eq!(v, result);
10605 let result = [0, 0, 0, 1, 1, 1, 6];
10606 assert_eq!(v, result);
10617 let result = [1, 1, 1, 0, 0, 0, 6];
10618 assert_eq!(v, result);
10637 let result = [2, 1, 1, 1, 0, 0, 0];
10638 assert_eq!(v, result);
10649 let result = [0, 1, 1, 1, 2, 2, 2];
10650 assert_eq!(v, result);
10669 let result = [0, 1, 1, 1, 0, 0, 0];
10670 assert_eq!(v, result);
10681 let result = [0, 0, 0, 0, 1, 1, 1];
10682 assert_eq!(v, result);
14616 let result = match init {
14620 let ptr = match result {
14938 fn handle_reserve(result: Result<(), TryReserveError>) {
14939 match result {
15138 let mut result = Vec::with_capacity(reserved_len);
15139 debug_assert!(result.capacity() >= reserved_len);
15141 result.extend_from_slice(first.borrow().as_ref());
15144 let pos = result.len();
15145 let target = result.get_unchecked_mut(pos..reserved_len);
15156 result.set_len(result_len);
15158 result
15241 let mut result = String::new();
15244 result.push_str(unsafe { self.get_unchecked(last_end..start) });
15245 result.push_str(to);
15248 result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });
15249 result
15280 let mut result = String::with_capacity(32);
15283 result.push_str(unsafe { self.get_unchecked(last_end..start) });
15284 result.push_str(to);
15287 result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });
15288 result
16175 //! converting to strings, and several error types that may result from
18522 /// The result is allocated on the heap.
19513 //! does not implement [`Send`][send]. As a result, the Rust compiler
19714 //! // need graceful error handling for a `None` result.
19848 /// to upgrade the weak reference before this function returns will result
19889 // weak pointer for ourselves, but this would result in additional
21567 let result = self.as_ptr();
21569 result
22704 let mut result = Vec::with_capacity(size);
22706 result.extend_from_slice(v.borrow())
22708 result
22723 let mut result = Vec::with_capacity(size);
22724 result.extend_from_slice(first.borrow());
22727 result.push(sep.clone());
22728 result.extend_from_slice(v.borrow())
22730 result
22746 let mut result = Vec::with_capacity(size);
22747 result.extend_from_slice(first.borrow());
22750 result.extend_from_slice(sep);
22751 result.extend_from_slice(v.borrow())
22753 result
22874 /// stores the result into `v[..]`.
23611 /// to upgrade the weak reference before this function returns will result
23648 // weak pointer for ourselves, but this would result in additional
24174 /// including potentially between calling this method and acting on the result.
24203 /// including potentially between calling this method and acting on the result.
24979 let result = self.as_ptr();
24981 result
26157 //! operation. This function only returns a result because writing to the
26298 //! The result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].
26309 //! [`Result`]: core::result::Result
26392 use std::result::Result::{Err, Ok};
29359 /// Some anonymous query, the result of which is already given.
29360 pub fn query<R>(&self, result: R) -> R {
29365 result
29564 /// The result is meaningful only if the tree is ordered by key, like the tree
29599 /// The result is meaningful only if the tree is ordered by key.
29664 /// The result is meaningful only if the tree is ordered by key.
29699 /// The result is meaningful only if the tree is ordered by key, like the tree
29715 /// The result is meaningful only if the tree is ordered by key, like the tree
29742 /// The result is meaningful only if the tree is ordered by key.
29854 /// The behavior resulting from such a logic error is not specified, but will not result in
32075 /// relevant function, and returns a result obtained along the way.
32100 /// Calculates the length of both trees that result from splitting up
32121 /// The result is meaningful only if the tree is ordered by key,
32191 /// The behavior resulting from such a logic error is not specified, but will not result in
32726 // Same result as self.difference(other).next().is_none()
33359 /// let result = &a - &b;
33360 /// let result_vec: Vec<_> = result.into_iter().collect();
33382 /// let result = &a ^ &b;
33383 /// let result_vec: Vec<_> = result.into_iter().collect();
33405 /// let result = &a & &b;
33406 /// let result_vec: Vec<_> = result.into_iter().collect();
33428 /// let result = &a | &b;
33429 /// let result_vec: Vec<_> = result.into_iter().collect();
33783 /// the result and/or calls to `next_back_unchecked` on the `back` of the
33784 /// result will eventually reach the same edge.
33855 /// The result is meaningful only if the tree is ordered by key, like the tree
33875 /// The result are non-unique references allowing (some) mutation, which must be used
33878 /// The result is meaningful only if the tree is ordered by key, like the tree
34226 let mut result = 0;
34228 Position::Leaf(node) => result += node.len(),
34229 Position::Internal(node) => result += node.len(),
34232 result
35176 /// Ensures a value is in the entry by inserting the result of the default function if empty,
35199 /// Ensures a value is in the entry by inserting, if empty, the result of the default function.
36753 let result = catch_unwind(AssertUnwindSafe(|| it.next()));
36754 assert!(matches!(result, Ok(None)));
38053 // is `Mut`. This is technically wrong, but cannot result in any unsafety due to
38784 let mut result = middle.split();
38787 Handle::new_edge(result.left.reborrow_mut(), insert_idx)
38790 Handle::new_edge(result.right.borrow_mut(), insert_idx)
38794 (InsertResult::Split(result), val_ptr)
38848 let mut result = middle.split();
38851 Handle::new_edge(result.left.reborrow_mut(), insert_idx)
38854 Handle::new_edge(result.right.borrow_mut(), insert_idx)
38858 InsertResult::Split(result)
38868 /// If the returned result is a `Fit`, its handle's node can be this edge's node or an ancestor.
38869 /// If the returned result is a `Split`, the `left` field will be the root node.
39148 result: F,
39198 result(parent_node, left_node)
39550 // Traversal isn't needede, it happens using the result of `borrow_mut`.
39655 let mut result = String::new();
39660 result += &format!("\n{}{:?}", indent, leaf.keys());
39666 result += &format!("\n{}{:?}", indent, kv.into_kv().0);
39669 result
39987 ) -> core::result::Result<(), core::fmt::Error> {
42922 /// If this deque is not partitioned, the returned result is unspecified and meaningless,
43895 let result = tester.split_off(at);
43898 assert!(result.tail < result.cap());
43899 assert!(result.head < result.cap());
43901 assert_eq!(result, expected_other);
44433 /// not result in undefined behavior. This could include panics, incorrect
46797 // write back the result.
48679 /// difference, with each additional slot filled with the result of
51795 * because Box<T> implements Unpin even when T does not, as a result of
51951 use core::result::Result::{Err, Ok};