additions

Author: Mark-Simulacrum

_posts/2018-08-02-Rust-1.28.md

@@ -25,13 +25,15 @@ appropriate page on our website, and check out the [detailed release notes for
 
 ### Global Allocators
 
-1.28.0 adds the `#[global_allocator]` attribute, which allows Rust programs to
-set their allocator, as well as define new allocators by implementing the
-[`GlobalAlloc`] trait.
+Allocators are the way that programs in Rust obtain memory from the system at
+runtime. Previously, Rust did not allow changing the way memory is obtained,
+which prevented some use cases. With 1.28.0, the `#[global_allocator]` attribute
+is now stable, which allows Rust programs to set their allocator to the system
+allocator, as well as define new allocators by implementing the [`GlobalAlloc`]
+trait.
 
-By default, Rust uses jemalloc on Linux systems, but this may not be ideal for
-specific use cases. The standard library provides a method for switching to the
-system allocator:
+The standard library provides a handle to the system allocator, which can be
+used as such:
 
 ```rust
 use std::alloc::System;
@@ -50,74 +52,57 @@ However, sometimes you want to define a custom allocator for a given application
 domain. This is also relatively easy to do by implementing the `GlobalAlloc`
 trait. You can read more about how to do this in the [documentation].
 
-[`GlobalAlloc`]: https://doc.rust-lang.org/1.28.0/std/alloc/trait.GlobalAlloc.html
-[documentation]: https://doc.rust-lang.org/1.28.0/std/alloc/trait.GlobalAlloc.html
+[`GlobalAlloc`]: https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html
+[documentation]: https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html
 
-### Library stabilizations
+### Improved error message for formatting
+
+Work on diagnostics continues, this time with an emphasis on formatting:
+
+```rust
+format!("{_foo}", _foo = 6usize);
+```
+
+Previously, the error message emitted here was relatively poor:
+
+```
+error: invalid format string: expected `'}'`, found `'_'`
+  |
+2 |     format!("{_foo}", _foo = 6usize);
+  |                     ^^^^^^^^
+```
 
-Several new APIs were stabilized this release:
-
-- [`Iterator::step_by`]
-- [`Path::ancestors`]
-- [`SystemTime::UNIX_EPOCH`]
-- [`alloc::GlobalAlloc`]
-- [`alloc::Layout`]
-- [`alloc::LayoutErr`]
-- [`alloc::System`]
-- [`alloc::alloc`]
-- [`alloc::alloc_zeroed`]
-- [`alloc::dealloc`]
-- [`alloc::realloc`]
-- [`alloc::handle_alloc_error`]
-- [`btree_map::Entry::or_default`]
-- [`fmt::Alignment`]
-- [`hash_map::Entry::or_default`]
-- [`iter::repeat_with`]
-- [`num::NonZeroUsize`]
-- [`num::NonZeroU128`]
-- [`num::NonZeroU16`]
-- [`num::NonZeroU32`]
-- [`num::NonZeroU64`]
-- [`num::NonZeroU8`]
-- [`ops::RangeBounds`]
-- [`slice::SliceIndex`]
-- [`slice::from_mut`]
-- [`slice::from_ref`]
-- [`{Any + Send + Sync}::downcast_mut`]
-- [`{Any + Send + Sync}::downcast_ref`]
-- [`{Any + Send + Sync}::is`]
+Now, we emit a diagnostic that tells you the specific reason the format string
+is invalid:
+
+```
+error: invalid format string: invalid argument name `_foo`
+  |
+2 |     let _ = format!("{_foo}", _foo = 6usize);
+  |                       ^^^^ invalid argument name in format string
+  |
+  = note: argument names cannot start with an underscore
+```
 
 See the [detailed release notes][notes] for more.
 
-[`Iterator::step_by`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.step_by
-[`Path::ancestors`]: https://doc.rust-lang.org/std/path/struct.Path.html#method.ancestors
-[`SystemTime::UNIX_EPOCH`]: https://doc.rust-lang.org/std/time/struct.SystemTime.html#associatedconstant.UNIX_EPOCH
-[`alloc::GlobalAlloc`]: https://doc.rust-lang.org/std/alloc/trait.GlobalAlloc.html
-[`alloc::Layout`]: https://doc.rust-lang.org/std/alloc/struct.Layout.html
-[`alloc::LayoutErr`]: https://doc.rust-lang.org/std/alloc/struct.LayoutErr.html
-[`alloc::System`]: https://doc.rust-lang.org/std/alloc/struct.System.html
-[`alloc::alloc`]: https://doc.rust-lang.org/std/alloc/fn.alloc.html
-[`alloc::alloc_zeroed`]: https://doc.rust-lang.org/std/alloc/fn.alloc_zeroed.html
-[`alloc::dealloc`]: https://doc.rust-lang.org/std/alloc/fn.dealloc.html
-[`alloc::realloc`]: https://doc.rust-lang.org/std/alloc/fn.realloc.html
-[`alloc::handle_alloc_error`]: https://doc.rust-lang.org/std/alloc/fn.handle_alloc_error.html
-[`btree_map::Entry::or_default`]: https://doc.rust-lang.org/std/collections/btree_map/enum.Entry.html#method.or_default
-[`fmt::Alignment`]: https://doc.rust-lang.org/std/fmt/enum.Alignment.html
-[`hash_map::Entry::or_default`]: https://doc.rust-lang.org/std/collections/btree_map/enum.Entry.html#method.or_default
-[`iter::repeat_with`]: https://doc.rust-lang.org/std/iter/fn.repeat_with.html
-[`num::NonZeroUsize`]: https://doc.rust-lang.org/std/num/struct.NonZeroUsize.html
-[`num::NonZeroU128`]: https://doc.rust-lang.org/std/num/struct.NonZeroU128.html
-[`num::NonZeroU16`]: https://doc.rust-lang.org/std/num/struct.NonZeroU16.html
-[`num::NonZeroU32`]: https://doc.rust-lang.org/std/num/struct.NonZeroU32.html
-[`num::NonZeroU64`]: https://doc.rust-lang.org/std/num/struct.NonZeroU64.html
-[`num::NonZeroU8`]: https://doc.rust-lang.org/std/num/struct.NonZeroU8.html
-[`ops::RangeBounds`]: https://doc.rust-lang.org/std/ops/trait.RangeBounds.html
-[`slice::SliceIndex`]: https://doc.rust-lang.org/std/slice/trait.SliceIndex.html
-[`slice::from_mut`]: https://doc.rust-lang.org/std/slice/fn.from_mut.html
-[`slice::from_ref`]: https://doc.rust-lang.org/std/slice/fn.from_ref.html
-[`{Any + Send + Sync}::downcast_mut`]: https://doc.rust-lang.org/std/any/trait.Any.html#method.downcast_mut-2
-[`{Any + Send + Sync}::downcast_ref`]: https://doc.rust-lang.org/std/any/trait.Any.html#method.downcast_ref-2
-[`{Any + Send + Sync}::is`]: https://doc.rust-lang.org/std/any/trait.Any.html#method.is-2
+### Library stabilizations
+
+We've already mentioned the stabilization of the `GlobalAlloc` trait, but
+another important stabilization is the [`NonZero`] types. These are wrappers
+around the standard unsigned integer types: `u8`, `u16, `u32`, `u64`, `u128`,
+and `usize`.
+
+This allows for size-optimization, for example, `Option<u8>` is two bytes large,
+but `Option<NonZeroU8>` is just one byte large. This is especially useful when
+the number represents an identifier and so you can guarantee that it is never
+going to be zero, reducing the size of optional identifiers at no visible cost
+to them.
+
+A number of other libraries have also been stabilized: you can see the more
+[detailed release notes][notes] for full details.
+
+[`NonZero`]: https://doc.rust-lang.org/stable/std/num/index.html
 
 ### Cargo features