Skip to content

Commit a09147c

Browse files
BennoLossinBennoLossin
committed
update doctests
1 parent 09b0922 commit a09147c

3 files changed

Lines changed: 26 additions & 66 deletions

File tree

‎README.md‎

Lines changed: 5 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,7 @@ let foo = pin_init!(Foo {
8585
(or just the stack) to actually initialize a `Foo`:
8686

8787
```rust
88-
let foo: Result<Pin<Box<Foo>>, core::alloc::AllocError> = Box::pin_init(foo);
88+
let foo: Result<Pin<Box<Foo>>, _> = Box::pin_init(foo);
8989
```
9090

9191
For more information see the [`pin_init!`] macro.
@@ -96,28 +96,25 @@ Many types that use this library supply a function/macro that returns an initial
9696
the above method only works for types where you can access the fields.
9797

9898
```rust
99-
let mtx: Result<Pin<Box<CMutex<usize>>>, AllocError> = Box::pin_init(CMutex::new(42));
99+
let mtx: Result<Pin<Arc<CMutex<usize>>>, _> = Arc::pin_init(CMutex::new(42));
100100
```
101101

102102
To declare an init macro/function you just return an [`impl PinInit<T, E>`]:
103103

104104
```rust
105-
use core::alloc::AllocError;
106105
#[pin_data]
107106
struct DriverData {
108107
#[pin]
109108
status: CMutex<i32>,
110109
buffer: Box<[u8; 1_000_000]>,
111110
}
112111

113-
struct DriverDataError;
114-
115112
impl DriverData {
116-
fn new() -> impl PinInit<Self, DriverDataError> {
113+
fn new() -> impl PinInit<Self, Error> {
117114
try_pin_init!(Self {
118115
status <- CMutex::new(0),
119-
buffer: Box::init(zeroed())?,
120-
}? DriverDataError)
116+
buffer: Box::init(pinned_init::zeroed())?,
117+
}? Error)
121118
}
122119
}
123120
```

‎src/lib.rs‎

Lines changed: 14 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,7 @@
9797
//! # a <- CMutex::new(42),
9898
//! # b: 24,
9999
//! # });
100-
//! let foo: Result<Pin<Box<Foo>>, core::alloc::AllocError> = Box::pin_init(foo);
100+
//! let foo: Result<Pin<Box<Foo>>, _> = Box::pin_init(foo);
101101
//! ```
102102
//!
103103
//! For more information see the [`pin_init!`] macro.
@@ -111,8 +111,9 @@
111111
//! # #![feature(allocator_api)]
112112
//! # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
113113
//! # use pinned_init::*;
114-
//! # use std::{alloc::AllocError, pin::Pin};
115-
//! let mtx: Result<Pin<Box<CMutex<usize>>>, AllocError> = Box::pin_init(CMutex::new(42));
114+
//! # use std::sync::Arc;
115+
//! # use core::pin::Pin;
116+
//! let mtx: Result<Pin<Arc<CMutex<usize>>>, _> = Arc::pin_init(CMutex::new(42));
116117
//! ```
117118
//!
118119
//! To declare an init macro/function you just return an [`impl PinInit<T, E>`]:
@@ -122,32 +123,21 @@
122123
//! # #![feature(allocator_api)]
123124
//! # use pinned_init::*;
124125
//! # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
125-
//! use core::alloc::AllocError;
126126
//! #[pin_data]
127127
//! struct DriverData {
128128
//! #[pin]
129129
//! status: CMutex<i32>,
130130
//! buffer: Box<[u8; 1_000_000]>,
131131
//! }
132132
//!
133-
//! struct DriverDataError;
134-
//!
135-
//! # impl From<core::convert::Infallible> for DriverDataError {
136-
//! # fn from(i: core::convert::Infallible) -> Self { match i {} }
137-
//! # }
138-
//! # impl From<AllocError> for DriverDataError {
139-
//! # fn from(_: AllocError) -> Self { Self }
140-
//! # }
141-
//! #
142133
//! impl DriverData {
143-
//! fn new() -> impl PinInit<Self, DriverDataError> {
134+
//! fn new() -> impl PinInit<Self, Error> {
144135
//! try_pin_init!(Self {
145136
//! status <- CMutex::new(0),
146-
//! buffer: Box::init(zeroed())?,
147-
//! }? DriverDataError)
137+
//! buffer: Box::init(pinned_init::zeroed())?,
138+
//! }? Error)
148139
//! }
149140
//! }
150-
//! # let _ = Box::pin_init(DriverData::new());
151141
//! ```
152142
//!
153143
//! ## Manual creation of an initializer
@@ -334,7 +324,6 @@ macro_rules! stack_pin_init {
334324
/// # #![feature(allocator_api)]
335325
/// # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
336326
/// # use pinned_init::*;
337-
/// # use core::{alloc::AllocError, pin::Pin, convert::Infallible};
338327
/// #[pin_data]
339328
/// struct Foo {
340329
/// #[pin]
@@ -361,7 +350,6 @@ macro_rules! stack_pin_init {
361350
/// # #![feature(allocator_api)]
362351
/// # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
363352
/// # use pinned_init::*;
364-
/// # use core::{alloc::AllocError, pin::Pin, convert::Infallible};
365353
/// #[pin_data]
366354
/// struct Foo {
367355
/// #[pin]
@@ -477,7 +465,6 @@ macro_rules! stack_try_pin_init {
477465
/// })
478466
/// }
479467
/// }
480-
/// # let _ = Box::pin_init(Foo::new());
481468
/// ```
482469
///
483470
/// Users of `Foo` can now create it like this:
@@ -551,7 +538,6 @@ macro_rules! stack_try_pin_init {
551538
/// })
552539
/// }
553540
/// }
554-
/// # let _ = Box::pin_init(FooContainer::new(0));
555541
/// ```
556542
///
557543
/// Here we see that when using `pin_init!` with `PinInit`, one needs to write `<-` instead of `:`.
@@ -802,35 +788,13 @@ pub unsafe trait PinInit<T: ?Sized, E = Infallible>: Sized {
802788
/// # Examples
803789
///
804790
/// ```rust
805-
/// # #![allow(clippy::disallowed_names)]
806-
/// # use core::{convert::Infallible, pin::Pin};
791+
/// # #![feature(allocator_api)]
792+
/// # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
807793
/// # use pinned_init::*;
808-
/// use pinned_init::pin_init_from_closure;
809-
/// #[repr(C)]
810-
/// struct RawFoo([u8; 16]);
811-
/// extern {
812-
/// fn init_foo(_: *mut RawFoo);
813-
/// }
814-
///
815-
/// #[pin_data]
816-
/// struct Foo {
817-
/// #[pin]
818-
/// raw: RawFoo,
819-
/// }
820-
///
821-
/// impl Foo {
822-
/// fn setup(self: Pin<&mut Self>) {
823-
/// println!("Setting up foo");
824-
/// }
825-
/// }
826-
///
827-
/// let foo = pin_init!(Foo {
828-
/// raw <- unsafe { pin_init_from_closure(|slot| {
829-
/// init_foo(slot);
830-
/// Ok::<_, Infallible>(())
831-
/// }) },
832-
/// }).pin_chain(|foo| {
833-
/// foo.setup();
794+
/// let mtx_init = CMutex::new(42);
795+
/// // Make the initializer print the value.
796+
/// let mtx_init = mtx_init.pin_chain(|mtx| {
797+
/// println!("{:?}", mtx.get_data_mut());
834798
/// Ok(())
835799
/// });
836800
/// ```
@@ -919,8 +883,6 @@ pub unsafe trait Init<T: ?Sized, E = Infallible>: PinInit<T, E> {
919883
/// ```rust
920884
/// # #![allow(clippy::disallowed_names)]
921885
/// # use pinned_init::*;
922-
/// # use core::convert::Infallible;
923-
/// use pinned_init::{self, init_from_closure};
924886
/// struct Foo {
925887
/// buf: [u8; 1_000_000],
926888
/// }
@@ -1243,7 +1205,7 @@ impl<T> InPlaceInit<T> for Arc<T> {
12431205
/// ```rust
12441206
/// # #![feature(allocator_api)]
12451207
/// # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
1246-
/// use pinned_init::*;
1208+
/// # use pinned_init::*;
12471209
/// use core::pin::Pin;
12481210
/// #[pin_data(PinnedDrop)]
12491211
/// struct Foo {

‎src/macros.rs‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,6 @@
2222
//! We will look at the following example:
2323
//!
2424
//! ```rust,ignore
25-
//! # use pinned_init::*;
26-
//! # use core::pin::Pin;
2725
//! #[pin_data]
2826
//! #[repr(C)]
2927
//! struct Bar<T> {
@@ -78,7 +76,6 @@
7876
//! Here is the definition of `Bar` from our example:
7977
//!
8078
//! ```rust,ignore
81-
//! # use pinned_init::*;
8279
//! #[pin_data]
8380
//! #[repr(C)]
8481
//! struct Bar<T> {
@@ -306,7 +303,10 @@
306303
//! };
307304
//! // Construct the initializer.
308305
//! let init = unsafe {
309-
//! ::pinned_init::pin_init_from_closure::<_, ::core::convert::Infallible>(init)
306+
//! ::pinned_init::pin_init_from_closure::<
307+
//! _,
308+
//! ::core::convert::Infallible,
309+
//! >(init)
310310
//! };
311311
//! init
312312
//! }
@@ -491,8 +491,9 @@
491491
//! | -> ::core::result::Result<(), ::core::convert::Infallible> {
492492
//! init(slot).map(|__InitOk| ())
493493
//! };
494-
//! let init =
495-
//! unsafe { ::pinned_init::pin_init_from_closure::<_, ::core::convert::Infallible>(init) };
494+
//! let init = unsafe {
495+
//! ::pinned_init::pin_init_from_closure::<_, ::core::convert::Infallible>(init)
496+
//! };
496497
//! init
497498
//! };
498499
//! ```

0 commit comments

Comments
 (0)