190 //! /// `foo` is always initialized
202 //!         // - when the closure returns `Ok(())`, then it has successfully initialized and
221 //!                     // All fields of `RawFoo` have been initialized, since `_p` is a ZST.
232 //!         // SAFETY: Since `foo` is initialized, destroying is safe.
571 /// The fields are initialized in the order that they appear in the initializer. So it is possible
572 /// to read already initialized fields using raw pointers.
683 /// This signifies that the given field is initialized in-place. As with `struct` initializers, just
804 /// - the fields are initialized in the order given in the initializer.
855 /// - the fields are initialized in the order given in the initializer.
985 /// - returns `Ok(())` if it initialized every field of `slot`,
989 ///     - `slot` is not partially initialized.
1014     /// First initializes the value using `self` then calls the function `f` with the initialized
1055         // SAFETY: The above call initialized `slot` and we still have unique access.  in __pinned_init()
1059         // SAFETY: `slot` was initialized above.  in __pinned_init()
1078 /// - returns `Ok(())` if it initialized every field of `slot`,
1082 ///     - `slot` is not partially initialized.
1112     /// First initializes the value using `self` then calls the function `f` with the initialized
1162         // SAFETY: The above call initialized `slot` and we still have unique access.  in __init()
1164             // SAFETY: `slot` was initialized above.  in __init()
1186 /// - returns `Ok(())` if it initialized every field of `slot`,
1190 ///     - `slot` is not partially initialized.
1205 /// - returns `Ok(())` if it initialized every field of `slot`,
1209 ///     - `slot` is not partially initialized.
1253                 // SAFETY: The loop has initialized the elements `slot[0..i]` and since we return
1262     // any initialized elements and returns `Err`.
1296                 // SAFETY: The loop has initialized the elements `slot[0..i]` and since we return
1305     // any initialized elements and returns `Err`.
1309 // SAFETY: Every type can be initialized by-value.
1318 // SAFETY: Every type can be initialized by-value. `__pinned_init` calls `__init`.
1328     /// The type `Self` turns into when the contents are initialized.
1329     type Initialized;  typedef
1334     fn write_init<E>(self, init: impl Init<T, E>) -> Result<Self::Initialized, E>;  in write_init()  argument
1339     fn write_pin_init<E>(self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E>;  in write_pin_init()  argument
1380 /// Marker trait for types that can be initialized by writing just zeroes.
1409     // and because we write all zeroes, the memory is initialized.  in zeroed()