sarvex
diff --git a/‎specification/terms.md
Lines changed: 84 additions & 21 deletions b/‎specification/terms.md
Lines changed: 84 additions & 21 deletions
@@ -1,6 +1,83 @@
-Some terms, defined by me. Please debate on them, or correct them, as you see fit :)
+My version of the OP
 
-* Object - Contiguous block of memory with a certain size and a certain alignment.
+## Statics
+
+### Type
+
+A rustc `Ty` - You should know what this is :-). Not to be confused with an LLVM type or anything else.
+
+### Concrete Type
+
+A *type* without type parameters.
+
+### Location Expression (lexpr)
+
+
+A typed expression that evaluates to an *object*, as opposed to a *vexpr*. The LHS of an assignment and the scrutinee of a pattern are examples of *lexpr*s.
+
+If a *vexpr* is used where an *lexpr* is expected (other than the LHS of an assignment, where
+using a *vexpr* is illegal), it is wrapped in an implicit *temporary lexpr*.
+
+### Value Expression (vexpr)
+
+A typed expression that evaluates to an *value*, as opposed to a *lexpr*. The RHS of an
+assignment and the arguments of a function are examples of *vexpr*s.
+
+If a *lexpr* is used where an *vexpr* is expected, it is wrapped in an implicit
+*use vexpr*.
+
+### Temporary Lexpr
+
+```Rust
+    LExprKind::Temp(P<VExpr>)
+```
+
+A kind of implicit *lexpr* that wraps a *vexpr* when a *lexpr* is needed. When
+ evaluated, it:
+
+ * creates a temporary slot, scheduled for destruction at the end of the current *temporary scope*.
+ * evaluates the *vexpr* and stores it within the slot.
+ * evaluates into the temporary slot object.
+
+A common example occurs when the result of `format!` is borrowed - it is wrapped by
+an implicit temporary lexpr.
+
+```Rust
+fn send(message: &str) {
+    /* .. */
+}
+
+fn main() {
+    let message = &format!("1+1={}", 1+1);
+    send(message);
+}
+```
+
+### Use Vexpr
+
+```Rust
+    LExprKind::Use(P<LExpr>)
+```
+
+A kind of implicit *vexpr* that wraps a *lexpr* when a *vexpr* is needed. When
+evaluated, it evaluates the *lexpr* and reads the *value* from the evaluated-to
+*object*.
+
+If the expression's type does not implement `Copy`, the value is moved out of the
+read-from *object*, preventing further accesses.
+
+The read-from *object* must be aligned to `align_of::<T>()` or behavior is undefined.
+
+As usual, all `size_of::<T>()` bytes of the *object* must be accessible and
+remain stable for the duration required by the aliasing rules.
+
+### Lvalue, Rvalue
+
+These terms are banned because they are used in conflicting ways in various places.
+
+## Dynamics
+
+### Object - Contiguous block of memory with a certain size and a certain alignment.
 
 Each object has the capability to read the memory.
 
@@ -28,26 +105,12 @@ let x: Box<i32> = Box::new(0i32); // a stack, read-only object pointing to a hea
                                   // read-write object of size >= 4, alignment >= 4
 ```
 
-* `lexpr` or `locator expression` - A typed expression which refers to a specific memory location, an object, as opposed to just a value - i.e., if you try to move it, and it's not Copy, there's a compiler error
-
-If you read a lexpr of type T, the object referred to by the lexpr must have `align_of::<T>()`, and `size_of::<T>()`. The bytes of the object gets read as the type of the lexpr, if they are valid; otherwise, undefined behavior.
-
-```rust
-let x: Box<i32> = Box::new(0i32);
--> x
--> *x
-```
-
-Both examples of expressions that refer to specific objects.
+A note:
 
-* `value` - A typed expression which refers only to a value - i.e., if you take the address, it must create a temporary.
+Objects aren't typed. No, not even effective types ^-^
 
-```rust
--> 0i32
-let x: i32 = 0i32;
--> &x
-```
+### Value - inhabitant of a type
 
-A note:
+A *value* is the inhabitant of a type. *Value*s are purely mathematical objects and neither live in memory not form part of a program statement. However, datums may be partially `undef` (do we want that?).
 
-Objects aren't typed. No, not even effective types ^-^
+Example values are `true: bool`, `[0, 0, 0, 0]: [u32; 4]`, `0xcccccccc: *const u32`, `the address of the local "foo": &u32`. `Some((4, 2)): Option<(u32, usize)>`.