Make filled_with more generic and recover from panics better.

[jswrenn]

More generic initializer.

The initializer is now an F: FnMut() -> T, allowing, for example, using a stateful closure to initialize the vec.

Better panic recovery.

If the initializer of filled_with panics, items pushed prior to the panic will be dropped.

[slightlyoutofphase]

Sorry it took me a bit to respond! Needed a little more time to consider than the other PR. Your idea is great WRT to the panic stuff, and using a FnMut instead of a fn instead is definitely more useful as far as what it can take as input.

That said, after looking at some assembler output, your code as written seems to inhibit the auto-vectorization of the initialization loop even in the best case scenario (release mode, no panic actually happens, etc.)

I played around with it a bit though, and found that the following has all of your intended benefits as far as dropping the items when things do go wrong, while also not preventing optimizations when things go fine:

///Returns a new StaticVec instance filled with the return value of an initializer function.
///The length field of the newly created StaticVec will be equal to its capacity.
///
///```rust
///use staticvec::*;
///
///fn main() {
///  let mut i = 0;
///  let v = StaticVec::<i32, 64>::filled_with(|| { i += 1; i });
///
///  assert_eq!(v.len(), 64);
///
///  assert_eq!(v[0], 1);
///  assert_eq!(v[1], 2);
///  assert_eq!(v[2], 3);
///  assert_eq!(v[3], 4);
///}
/// ```
#[inline]
pub fn filled_with<F>(mut initializer: F) -> Self
where F: FnMut() -> T {
  unsafe {
    let mut res = Self {
      data: MaybeUninit::uninit().assume_init(),
      length: 0,
    };
    for i in 0..N {
      res.data.get_unchecked_mut(i).write(initializer());
      res.length += 1;
    }
    res
  }
}

If you want to switch it out in your branch for that (so you can still get "credit" for the commit), I'm happy to merge it right away.

[jswrenn]

I've amended the PR! You're right, push_unchecked essentially needs to be manually inlined to get auto vectorization. It looks like calling Self::new() vs inlining it doesn't make a difference, however.

[slightlyoutofphase]

Sold to the highest bidder! Or, merged.

(This kinda thing is why people who say "never ever ever use #[inline(always)]!" are straight up wrong, I'll note.)

[jswrenn]

Huzzah!

It's also an example of why relying on inline(always) to ensure an abstraction is zero-cost might fall flat. :(

[slightlyoutofphase]

It's also an example of why relying on inline(always) to ensure an abstraction is zero-cost might fall flat. :(

For sure. That's basically why I always use --emit asm to compare the output after making any change that might unintentionally throw off the optimizer.

Thanks again for the contribution BTW, I probably wouldn't have ever thought to use FnMut or improve the panic handling on my own.