The recent discussion about the word 'lifetime' in rust interests me, because it is something I found confusing at first... but I still don't see any of the alternatives ('scope', 'lifespan', 'borrow bound') as being any meaningful improvement.

I think the lifetime guides should be more explicit about how memory management occurs.

Something like this:

    When the instance X of type T is freed in rust and its destructor (if any) 
    is invoked, we refer to this as 'dropping' X.

    X will be dropped if:

    - It goes out of a scope
    - It's immediate parent is dropped

    *T in rust is a 'raw' pointer, like a C pointer.

    *T can result in a segmentation fault like in C, if the memory it points
    to has already been dropped (Use after free).

    &T is a special type in rust that prevents use after free errors by 
    applying compile time guards enforcing safe usage.

    Typically the compile time guards are automatically determined using
    static analysis, but sometimes ambiguities require explicit hints when
    writing an API. In these cases it is necessary to hint to static type
    checker what the the appropriate lifetime for a &T is.

The existing lifetime definition:

    A lifetime is a static approximation of the span of 
    execution during which the pointer is valid

Doesn't really cut it for me.

It needs to be explicit 1) that lifetimes are for the static type checker, and 2) that they are more than just for borrowed pointers.

For example, for a trait or closure, the lifetime is not the duration during which the pointer is valid. It's a lower bound on the possible lifetimes of other types that can go into either that closure or trait.

For example, to pass a closure to a thread it must be 'static, which means that the lower bound for any lifetime used in the closure is static. This for example:

    let foo = 0u;
    let bar = |:| { let y = foo + 1; ... }

The closure in this example has a lifetime which is <= the lifetime of foo, which it uses. This is < 'static, so bar cannot be 'static.

The same is true of structures and traits. A boxed trait Box<Foo + 'a> means the struct implementing Foo contained in the box must have an lifetime of at least 'a.

It's almost like we have two completely separate ideas:

1) Lifetime <--- The lifetime of a borrowed pointer

2) Lifetime bound <---- The lifetime on a closure, struct, trait, etc.