News for hackers. Stuff that matters.
Re:Announcing Rust 1.28 by ainar-g on Thursday August 02, 2018 @12:22PM (#17672709)
I wonder, why is it NonZeroU8, NonZeroU16, etc instead of something like NonZero<u8>, NonZero<u16>, etc?

In theory, in the future, when Rust supports constants as template arguments, one might even add a const argument, the value that should be used as "null". E.g. if my u8 never reaches 255, I could use something like Never<u8, 255>.

Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @12:29PM (#17672782)
We used to have NonZero<T>, but changed it https://github.com/rust-lang/rfcs/blob/b728bf68703f681ef0e42...

The real motivation is

> With NonNull covering pointers, the remaining use cases for NonZero are integers.

It's unclear how extensible we truly want this to be, and so we decided to go with the concrete types. In the worst case, we'd eventually re-introduce some sort of NonZero<T>, and deprecate these types. This was deemed worth it to let people use this important feature on stable, rather than waiting and seeing if we ever decide to do otherwise.

Re:Announcing Rust 1.28 by Arnavion on Thursday August 02, 2018 @12:27PM (#17672764)
>I wonder, why is it NonZeroU8, NonZeroU16, etc instead of something like NonZero<u8>, NonZero<u16>, etc?

The RFC covers this. https://github.com/rust-lang/rfcs/blob/master/text/2307-conc... Also see the RFC discussion at https://github.com/rust-lang/rfcs/pull/2307

Basically the generic NonZero already existed, but it's hard to express safely when used with arbitrary user types.

>In theory, in the future, when Rust supports constants as template arguments, one might even add a const argument, the value that should be used as "null". E.g. if my u8 never reaches 255, I could use something like Never<u8, 255>.

This requires const generics, so it could happen when they're implemented. (This is also mentioned in the RFC discussion.)

Re:Announcing Rust 1.28 by lmm on Thursday August 02, 2018 @01:28PM (#17673455)
Does "const generics" essentially mean singleton types?
Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @01:36PM (#17673523)
There are so many "slightly different but mostly the same" things in this space. In Rust, this is const generics: https://github.com/rust-lang/rfcs/blob/master/text/2000-cons...

  struct RectangularArray<T, const WIDTH: usize, const HEIGHT: usize> {
      array: [[T; WIDTH]; HEIGHT],
  }

  const X: usize = 7;

  fn main() {
      let x: RectangularArray<i32, 2, 4>;
      let y: RectangularArray<i32, X, {2 * 2}>;
  }
I haven't read enough about singleton types to know the exact details about their similarities, so I'm not sure.
Re:Announcing Rust 1.28 by lordnaikon on Thursday August 02, 2018 @06:37PM (#17676053)
Is this what is known as pi or dependent types?
Re:Announcing Rust 1.28 by eddyb on Friday August 03, 2018 @03:44AM (#17677976)
Yes, but limited to being applied at compile-time, with constant arguments.

Fully general dependent type would allow passing in runtime values, which is significantly harder to type-check and execute

Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @07:26PM (#17676289)
I believe that this initial version is not quite fully pi types; we did have an RFC for those but it was deemed too large to start off with.
Re:Announcing Rust 1.28 by asdkhadsj on Thursday August 02, 2018 @12:38PM (#17672878)
Can anyone brief what NonZero even is.. or rather, it's application? From the sounds of it, it's literally just a u8 (or w/e) that can't be zero.. but what use case does that have?
Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @12:50PM (#17672998)
Let's take an enum, like Option:

    enum Option<T> {
        Some(T),
        None,
    }
Under the hood, this is a "tagged union"; Rust has to have enough space for the T, but also for a tag, to say which variant is the current one.

If T is a NonZero type, then we know that zero is never a valid value. That means that instead, Rust can use the zero value to mean the None case, and any other value to be the Some case, completely eliminating the extra tag, and reducing the size of the Option.

This is a good example of a "zero-cost abstraction"; an Option in this case has absolutely no extra associated overhead at runtime.

Note that these optimizations aren't specialized for Option; they apply to anything that has this kind of shape.

Re:Announcing Rust 1.28 by slavik81 on Friday August 03, 2018 @02:58AM (#17677763)
I've occasionally thought that if I were to design my own language, it would be nice to try using INT_MIN as the invalid value that marks None. I've never actually used the extra negative value you get from twos-compliment, so giving it up in exchange for a smaller Option<T> seems like an excellent trade. Though, I wonder if that might have some complications for stuff like overflow checking.

I suppose you could always wrap NonZero with an accessor that adds 1 if negative to achieve the same result, though that might be too much overhead to be worth it.

Re:Announcing Rust 1.28 by monocasa on Thursday August 02, 2018 @01:21PM (#17673375)
Is NonZero* special cased by the language? If for instance, I had a preexisting binary interface where 0 through (2^n - 2) is valid, but all bits set is the invalid case, can I explain that to the compiler as well?
Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @01:24PM (#17673414)
Yes, it is. The case you're talking about is pertinent to the above discussion on why it's NonZero* vs NonZero<T>; you cannot currently inform the compiler in your case.
Re:Announcing Rust 1.28 by mrec on Thursday August 02, 2018 @01:40PM (#17673568)
Excellent explanation. Have you considered writing some sort of book? :P
Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @02:36PM (#17674176)
Heh, thank you. There's too many books that I want to write...
Re:Announcing Rust 1.28 by asdkhadsj on Thursday August 02, 2018 @01:21PM (#17673393)
That's actually really cool! Thanks for the explanation
Re:Announcing Rust 1.28 by steveklabnik on Thursday August 02, 2018 @01:23PM (#17673406)
No problem!
Re:Announcing Rust 1.28 by eptcyka on Friday August 03, 2018 @05:29AM (#17678409)
Whilst a great response, I think the practical implication of being able to ensure you never divide by zero did not shine through :)
Re:Announcing Rust 1.28 by bryanlarsen on Thursday August 02, 2018 @01:21PM (#17673379)
It's also useful for divisors.