Say "use" rather than "call" for unsafe extern items

We can have static items as well as function items within an `extern`
block, so let's say "use" rather than "call" when referring to these.
Let's also give an example of a static item to show how `safe` allows
for safe access to these items.

Author: traviscross

posts/2024-10-17-Rust-1.82.0.md

@@ -170,20 +170,21 @@ The native syntax makes it more clear that the operand expression of these opera
 
 ### Safe items with `unsafe extern`
 
-Rust code can use functions and statics from foreign code.  The type signatures of these foreign items are provided in `extern` blocks.  Historically, all items within `extern` blocks have been unsafe to call, but we didn't have to write `unsafe` anywhere on the `extern` block itself.
+Rust code can use functions and statics from foreign code.  The type signatures of these foreign items are provided in `extern` blocks.  Historically, all items within `extern` blocks have been unsafe to use, but we didn't have to write `unsafe` anywhere on the `extern` block itself.
 
 However, if a signature within the `extern` block is incorrect, then using that item will result in undefined behavior.  Would that be the fault of the person who wrote the `extern` block, or the person who used that item?
 
 We've decided that it's the responsibility of the person writing the `extern` block to ensure that all signatures contained within it are correct, and so we now allow writing `unsafe extern`:
 
 ```rust
 unsafe extern {
+    pub safe static TAU: f64;
     pub safe fn sqrt(x: f64) -> f64;
     pub unsafe fn strlen(p: *const u8) -> usize;
 }
 ```
 
-One benefit of this is that items within an `unsafe extern` block can be marked as safe to call.  In the above example, we can call `sqrt` without using `unsafe`.  Items that aren't marked with either `safe` or `unsafe` are conservatively assumed to be `unsafe`.
+One benefit of this is that items within an `unsafe extern` block can be marked as safe to use.  In the above example, we can call `sqrt` or read `TAU` without using `unsafe`.  Items that aren't marked with either `safe` or `unsafe` are conservatively assumed to be `unsafe`.
 
 In future releases, we'll be encouraging the use of `unsafe extern` with lints.  Starting in Rust 2024, using `unsafe extern` will be required.