nomicon | Implementation walkthrough of the NearProtocol client | Development Tools library

You are thinking about lifetime in the wrong way. The lifetime of r doesn't get specialized into neither 'x nor 'y. It has its own lifetime (lets call it 'r).

As explained in the Non-Lexical Lifetimes RFC, the lifetime of a value (or its scope as the RFC calls it) is the points on the program where the value may still be used in the future. Crucially, lifetimes aren't necessarily linear, nor do they have to fit to a specific syntax scope (i.e. a {} block). Additionally, lifetimes aren't connected to a variable (like r), but the values they are bound to. Therefore, if you assign to a variable (i.e. r = ..), you effectively killing one value and starting another. It doesn't count as a usage. However, assigning to a member of a value (i.e. r.0 = ..), is a usage, since you are changing a small part of an existing value.

In your case, 'r has two starting points and two end points. The first start point is at r = Wrapper(&x); and the first endpoint is at the first drop(r). The second start and end points are in the y-block. Visualized:

There are 2 reasons:

1. Optimize the execution for transactions on the same account. This saves us a few reads and serialization and executes faster.
2. Original goal: Allow to execute staking operation on a congested shard. Because the staking operation is performed on your own account, such transaction will be executed in front of the delayed queue of the receipts. This assumption is likely to change if NEAR Protocol switches to different receipt priority, e.g. based on gas price or some premium.

EDIT: To answer the first question. The local receipt can only be created from a conversion of a transaction to a receipt.

The page you linked says:

Currently the only properly supported way to create a custom DST is by making your type generic and performing an unsizing coercion: …

(Yes, custom DSTs are a largely half-baked feature for now.)

The thing you're asking for is entirely reasonable in context — it just doesn't exist yet. The unsizing coercion requires that the size is known at the coercion site.

I thought it might be interesting to try to make it work anyway by liberally applying unsafe. Don't use this for anything — I am not really familiar with writing good unsafe Rust code and just tinkered with things until it worked. There are probably even ways to get the same thing done with fewer hazards.

This code is for entertainment purposes only.

When you call your A::a method, it borrows a whole variable it implemented for. So you can't have immutable references to the same object (or it's content) at the same time.

You'll never be able to do what you want as you can't guarantee to the compiler that the closure will NEVER go out of scope for the applications life time (which you'd have to do in this case because the compiler has no idea how long you'll hold on to the &Value reference).

Instead, since it looks like you're reading the configuration from disk only once why not store it in a static variable with the help of the lazy_static crate.

You're confusing yourself with the whole T stuff. This should be much easier to analyze. Specifically, read here.

Then why does rust libc use repr(packed) and not repr(C) for passing struct to system libc?

One obvious reason is that the equivalent structures are specified as packed on the C side as well. (Many C compilers support "packed" as a non-standard extension with the same meaning as in Rust.) The definition of epoll_event on Linux confirms this:

I can do other nasty things with this MyBox that have nothing to do with Drop...

nullable pointer optimization.

If the Option contains a pointer type, such as Box then the optimisation can be applied. A u8 cannot be null and is not a pointer, but a Box is an owned pointer to a u8, so the optimisation works there.

More generally, this optimisation is called "niche-filling" which also applies to a few non-pointer Rust types, notably enums. In the general case this is not safe for FFI though, and therefore doesn't apply to data in #[repr(C)] structs except for pointer types.