This is a known issue regarding how the function traits are inferred through Deref. As a workaround, you need to explicitly get a mutable reference by doing a mutable reborrow: let mut t = Foo; (&mut *t)(); or by calling DerefMut::deref_mut: let mut t = Foo; t.deref_mut()();
I think the second opus of What every C programmer should know about Undefined Behavior might help illustrate this issue. Taking the example of the blog: void contains_null_check(int *P) { int dead = *P; if (P == 0) return; *P = 4; } Might be optimized to (RNCE: Redundant Null Check Elimintation): void contains_null_check_after_RNCE(int *P) … Read more
I assume you mean “is an iterator valid,” that it hasn’t been invalidated due to changes to the container (e.g., inserting/erasing to/from a vector). In that case, no, you cannot determine if an iterator is (safely) dereferencable.
The standard correctly defines the return type of an assignment operator. Actually, the assignment operation itself doesn’t depend on the return value – that’s why the return type isn’t straightforward to understanding. The return type is important for chaining operations. Consider the following construction: a = b = c;. This should be equal to a … Read more
Reviewing the basic terminology It’s usually good enough – unless you’re programming assembly – to envisage a pointer containing a numeric memory address, with 1 referring to the second byte in the process’s memory, 2 the third, 3 the fourth and so on…. What happened to 0 and the first byte? Well, we’ll get to … Read more
Rust usually focuses on object value (i.e. the interesting part of the contents) rather than object identity (memory addresses). The implementation of Display for &T where T implements Display defers directly to the contents. Expanding that macro manually for the String implementation of Display: impl<‘a> Display for &’a String { fn fmt(&self, f: &mut Formatter) … Read more
Why does this work? This works because sizeof is a compile time construct, with the exception of variable length arrays is not evaluated at all. If we look at the C99 draft standard section 6.5.3.4 The sizeof operator paragraph 2 says(emphasis mine): […] The size is determined from the type of the operand. The result … Read more
“Dereferencing” is actually a confusing word for that purpose. Its not that, you just cache some property/method in a local variable. It actually makes no difference whether you do it to access some property/method on a random object or do it with Array.prototype.slice. It makes a lot of sense as soon as you access those … Read more
These statements produce different results because of the way in which the operators bind. In particular, the prefix ++ operator has the same precedence as *, and they associate right-to-left. Thus ++*ptr is parsed as ++(*ptr) meaning “increment the value pointed at by ptr,”. On the other hand, the postfix ++ operator has higher precedence … Read more
the rules regarding Deref and DerefMut were designed specifically to accommodate smart pointers. Because of this, Deref should only be implemented for smart pointers to avoid confusion. — std::ops::Deref I think it’s a bad practice. since I can use my newtype as if it were the underlying type in some situations That’s the problem — … Read more