approach 1: &mut MaybeUninit<[T; N]>

having that type as an argument to a function is not flexible because you need
to pick a value for N -- limiting the size of the buffer that can be passed.

&mut MaybeUninit<[T]> would be more flexible but it doesn't exist.

&mut MaybeUninit<[T; N]> will become more flexible once we have const generics.

Author: japaric

src/libcore/fmt/float.rs

@@ -24,7 +24,7 @@ fn float_to_decimal_common_exact<T>(fmt: &mut Formatter, num: &T,
         let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
         let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,
                                                     *num, sign, precision,
-                                                    false, buf.get_mut(), parts.get_mut());
+                                                    false, buf.get_mut(), &mut parts);
         fmt.pad_formatted_parts(&formatted)
     }
 }

src/libcore/num/flt2dec/mod.rs

@@ -131,6 +131,8 @@ functions.
             issue = "0")]
 
 use i16;
+use mem::MaybeUninit;
+use {ptr, slice};
 pub use self::decoder::{decode, DecodableFloat, FullDecoded, Decoded};
 
 pub mod estimator;
@@ -604,32 +606,32 @@ pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T,
 /// `[+][0.][0000][2][0000]` with `frac_digits = 10`.
 pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,
                                     sign: Sign, frac_digits: usize, _upper: bool,
-                                    buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>
+                                    buf: &'a mut [u8],
+                                    parts: &'a mut MaybeUninit<[Part<'a>; 4]>) -> Formatted<'a>
         where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16) {
-    assert!(parts.len() >= 4);
-
     let (negative, full_decoded) = decode(v);
     let sign = determine_sign(sign, &full_decoded, negative);
+    let parts_head = parts.as_mut_ptr() as *mut Part;
     match full_decoded {
-        FullDecoded::Nan => {
-            parts[0] = Part::Copy(b"NaN");
-            Formatted { sign, parts: &parts[..1] }
+        FullDecoded::Nan => unsafe {
+            ptr::write(parts_head, Part::Copy(b"NaN"));
+            Formatted { sign, parts: slice::from_raw_parts(parts_head, 1) }
         }
-        FullDecoded::Infinite => {
-            parts[0] = Part::Copy(b"inf");
-            Formatted { sign, parts: &parts[..1] }
+        FullDecoded::Infinite => unsafe {
+            ptr::write(parts_head, Part::Copy(b"inf"));
+            Formatted { sign, parts: slice::from_raw_parts(parts_head, 1) }
         }
-        FullDecoded::Zero => {
+        FullDecoded::Zero => unsafe {
             if frac_digits > 0 { // [0.][0000]
-                parts[0] = Part::Copy(b"0.");
-                parts[1] = Part::Zero(frac_digits);
-                Formatted { sign, parts: &parts[..2] }
+                ptr::write(parts_head, Part::Copy(b"0."));
+                ptr::write(parts_head.offset(1), Part::Zero(frac_digits));
+                Formatted { sign, parts: slice::from_raw_parts(parts_head, 2) }
             } else {
-                parts[0] = Part::Copy(b"0");
-                Formatted { sign, parts: &parts[..1] }
+                ptr::write(parts_head, Part::Copy(b"0"));
+                Formatted { sign, parts: slice::from_raw_parts(parts_head, 1) }
             }
         }
-        FullDecoded::Finite(ref decoded) => {
+        FullDecoded::Finite(ref decoded) => unsafe {
             let maxlen = estimate_max_buf_len(decoded.exp);
             assert!(buf.len() >= maxlen);
 
@@ -644,18 +646,17 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,
                 // only after the final rounding-up; it's a regular case with `exp = limit + 1`.
                 debug_assert_eq!(len, 0);
                 if frac_digits > 0 { // [0.][0000]
-                    parts[0] = Part::Copy(b"0.");
-                    parts[1] = Part::Zero(frac_digits);
-                    Formatted { sign, parts: &parts[..2] }
+                    ptr::write(parts_head, Part::Copy(b"0."));
+                    ptr::write(parts_head.offset(1), Part::Zero(frac_digits));
+                    Formatted { sign, parts: slice::from_raw_parts(parts_head, 2) }
                 } else {
-                    parts[0] = Part::Copy(b"0");
-                    Formatted { sign, parts: &parts[..1] }
+                    ptr::write(parts_head, Part::Copy(b"0"));
+                    Formatted { sign, parts: slice::from_raw_parts(parts_head, 2) }
                 }
             } else {
                 Formatted { sign,
-                            parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) }
+                            parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts.get_mut()) }
             }
         }
     }
 }
-