ownership

I'm reading Xcode's documentation, and here is something that puzzles me: __block typeof(self) tmpSelf = self; [self methodThatTakesABlock:^ { [tmpSelf doSomething]; }]; The following is copied from the documentation: A block forms a strong reference to variables it captures. If you use self within a block, the block forms a strong reference to self , so if self also has a strong reference to the block (which it typically does), a strong reference cycle results. To avoid the cycle, you need to create a weak (or __block ) reference to self outside the block, as in the example above. I don't

In Rust, there are two possibilities to take a reference Borrow , i.e., take a reference but don't allow mutating the reference destination. The & operator borrows ownership from a value. Borrow mutably , i.e., take a reference to mutate the destination. The &mut operator mutably borrows ownership from a value. The Rust documentation about borrowing rules says: First, any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time: one or more references ( &T ) to a resource, exactly one

I have a data structure which can be represented as a unidirectional graph between some structs linked with link objects because links contain metadata. It looks something like this: struct StateMachine { resources: Vec<Resource>, links: Vec<Link>, } struct Resource { kind: ResourceType, // ... } enum LinkTarget { ResourceList(Vec<&Resource>), LabelSelector(HashMap<String, String>), } struct Link { from: LinkTarget, to: LinkTarget, metadata: SomeMetadataStruct, } The whole structure needs to be mutable because I need to be able to add and remove links and resources at runtime. Because of this,

I'm tring to replace a value in a mutable borrow; moving part of it into the new value: enum Foo<T> { Bar(T), Baz(T), } impl<T> Foo<T> { fn switch(&mut self) { *self = match self { &mut Foo::Bar(val) => Foo::Baz(val), &mut Foo::Baz(val) => Foo::Bar(val), } } } The code above doesn't work, and understandibly so, moving the value out of self breaks the integrity of it. But since that value is dropped immediately afterwards, I (if not the compiler) could guarantee it's safety. Is there some way to achieve this? I feel like this is a job for unsafe code, but I'm not sure how that would work.

I am confused with borrowing and ownership. In the Rust documentation about reference and borrowing let mut x = 5; { let y = &mut x; *y += 1; } println!("{}", x); They say println! can borrow x . I am confused by this. If println! borrows x , why does it pass x not &x ? I try to run this code below fn main() { let mut x = 5; { let y = &mut x; *y += 1; } println!("{}", &x); } This code is identical with the code above except I pass &x to println! . It prints '6' to the console which is correct and is the same result as the first code. Chris Morgan The macros print! , println! , eprint! ,