diff --git a/src/net/tcp.rs b/src/net/tcp.rs
index 4e89b45..798f214 100644
--- a/src/net/tcp.rs
+++ b/src/net/tcp.rs
@@ -33,23 +33,32 @@
 ///
 /// ```
 /// # use std::net::TcpListener;
-/// # let _listener = TcpListener::bind("127.0.0.1:3454").unwrap();
+/// # use std::error::Error;
+/// #
+/// # fn try_main() -> Result<(), Box<Error>> {
+/// #     let _listener = TcpListener::bind("127.0.0.1:3454")?;
 /// use mio::{Events, Ready, Poll, PollOpt, Token};
 /// use mio::tcp::TcpStream;
 /// use std::time::Duration;
 ///
-/// let stream = TcpStream::connect(&"127.0.0.1:34254".parse().unwrap()).unwrap();
+/// let stream = TcpStream::connect(&"127.0.0.1:34254".parse()?)?;
 ///
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 /// let mut events = Events::with_capacity(128);
 ///
 /// // Register the socket with `Poll`
 /// poll.register(&stream, Token(0), Ready::writable(),
-///               PollOpt::edge()).unwrap();
+///               PollOpt::edge())?;
 ///
-/// poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
+/// poll.poll(&mut events, Some(Duration::from_millis(100)))?;
 ///
 /// // The socket might be ready at this point
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 #[derive(Debug)]
 pub struct TcpStream {
@@ -441,22 +450,30 @@
 /// # Examples
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Events, Ready, Poll, PollOpt, Token};
 /// use mio::tcp::TcpListener;
 /// use std::time::Duration;
 ///
-/// let listener = TcpListener::bind(&"127.0.0.1:34254".parse().unwrap()).unwrap();
+/// let listener = TcpListener::bind(&"127.0.0.1:34254".parse()?)?;
 ///
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 /// let mut events = Events::with_capacity(128);
 ///
 /// // Register the socket with `Poll`
 /// poll.register(&listener, Token(0), Ready::writable(),
-///               PollOpt::edge()).unwrap();
+///               PollOpt::edge())?;
 ///
-/// poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
+/// poll.poll(&mut events, Some(Duration::from_millis(100)))?;
 ///
 /// // There may be a socket ready to be accepted
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 #[derive(Debug)]
 pub struct TcpListener {
diff --git a/src/poll.rs b/src/poll.rs
index 67566c6..691c57f 100644
--- a/src/poll.rs
+++ b/src/poll.rs
@@ -89,38 +89,46 @@
 /// A basic example -- establishing a `TcpStream` connection.
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Events, Poll, Ready, PollOpt, Token};
 /// use mio::tcp::TcpStream;
 ///
 /// use std::net::{TcpListener, SocketAddr};
 ///
 /// // Bind a server socket to connect to.
-/// let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
-/// let server = TcpListener::bind(&addr).unwrap();
+/// let addr: SocketAddr = "127.0.0.1:0".parse()?;
+/// let server = TcpListener::bind(&addr)?;
 ///
 /// // Construct a new `Poll` handle as well as the `Events` we'll store into
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 /// let mut events = Events::with_capacity(1024);
 ///
 /// // Connect the stream
-/// let stream = TcpStream::connect(&server.local_addr().unwrap()).unwrap();
+/// let stream = TcpStream::connect(&server.local_addr()?)?;
 ///
 /// // Register the stream with `Poll`
-/// poll.register(&stream, Token(0), Ready::all(), PollOpt::edge()).unwrap();
+/// poll.register(&stream, Token(0), Ready::all(), PollOpt::edge())?;
 ///
 /// // Wait for the socket to become ready. This has to happens in a loop to
 /// // handle spurious wakeups.
 /// loop {
-///     poll.poll(&mut events, None).unwrap();
+///     poll.poll(&mut events, None)?;
 ///
 ///     for event in &events {
 ///         if event.token() == Token(0) && event.readiness().is_writable() {
 ///             // The socket connected (probably, it could still be a spurious
 ///             // wakeup)
-///             return;
+///             return Ok(());
 ///         }
 ///     }
 /// }
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// # Edge-triggered and level-triggered
@@ -257,20 +265,28 @@
 /// For example:
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Poll, Ready, PollOpt, Token};
 /// use mio::tcp::TcpStream;
 /// use std::time::Duration;
 /// use std::thread;
 ///
-/// let sock = TcpStream::connect(&"216.58.193.100:80".parse().unwrap()).unwrap();
+/// let sock = TcpStream::connect(&"216.58.193.100:80".parse()?)?;
 ///
 /// thread::sleep(Duration::from_secs(1));
 ///
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 ///
 /// // The connect is not guaranteed to have started until it is registered at
 /// // this point
-/// poll.register(&sock, Token(0), Ready::all(), PollOpt::edge()).unwrap();
+/// poll.register(&sock, Token(0), Ready::all(), PollOpt::edge())?;
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// # Implementation notes
@@ -603,6 +619,8 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Poll, Events};
     /// use std::time::Duration;
     ///
@@ -616,8 +634,14 @@
     ///
     /// // Wait for events, but none will be received because no `Evented`
     /// // handles have been registered with this `Poll` instance.
-    /// let n = poll.poll(&mut events, Some(Duration::from_millis(500))).unwrap();
+    /// let n = poll.poll(&mut events, Some(Duration::from_millis(500)))?;
     /// assert_eq!(n, 0);
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     pub fn new() -> io::Result<Poll> {
         is_send::<Poll>();
@@ -703,15 +727,17 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Poll, Ready, PollOpt, Token};
     /// use mio::tcp::TcpStream;
     /// use std::time::{Duration, Instant};
     ///
-    /// let poll = Poll::new().unwrap();
-    /// let socket = TcpStream::connect(&"216.58.193.100:80".parse().unwrap()).unwrap();
+    /// let poll = Poll::new()?;
+    /// let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?;
     ///
     /// // Register the socket with `poll`
-    /// poll.register(&socket, Token(0), Ready::all(), PollOpt::edge()).unwrap();
+    /// poll.register(&socket, Token(0), Ready::all(), PollOpt::edge())?;
     ///
     /// let mut events = Events::with_capacity(1024);
     /// let start = Instant::now();
@@ -722,19 +748,25 @@
     ///
     ///     if elapsed >= timeout {
     ///         // Connection timed out
-    ///         return;
+    ///         return Ok(());
     ///     }
     ///
     ///     let remaining = timeout - elapsed;
-    ///     poll.poll(&mut events, Some(remaining)).unwrap();
+    ///     poll.poll(&mut events, Some(remaining))?;
     ///
     ///     for event in &events {
     ///         if event.token() == Token(0) {
     ///             // Something (probably) happened on the socket.
-    ///             return;
+    ///             return Ok(());
     ///         }
     ///     }
     /// }
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     pub fn register<E: ?Sized>(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>
         where E: Evented
@@ -780,19 +812,27 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Poll, Ready, PollOpt, Token};
     /// use mio::tcp::TcpStream;
     ///
-    /// let poll = Poll::new().unwrap();
-    /// let socket = TcpStream::connect(&"216.58.193.100:80".parse().unwrap()).unwrap();
+    /// let poll = Poll::new()?;
+    /// let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?;
     ///
     /// // Register the socket with `poll`, requesting readable
-    /// poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge()).unwrap();
+    /// poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge())?;
     ///
     /// // Reregister the socket specifying a different token and write interest
     /// // instead. `PollOpt::edge()` must be specified even though that value
     /// // is not being changed.
-    /// poll.reregister(&socket, Token(2), Ready::writable(), PollOpt::edge()).unwrap();
+    /// poll.reregister(&socket, Token(2), Ready::writable(), PollOpt::edge())?;
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     ///
     /// [`struct`]: #
@@ -829,23 +869,31 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Poll, Ready, PollOpt, Token};
     /// use mio::tcp::TcpStream;
     /// use std::time::Duration;
     ///
-    /// let poll = Poll::new().unwrap();
-    /// let socket = TcpStream::connect(&"216.58.193.100:80".parse().unwrap()).unwrap();
+    /// let poll = Poll::new()?;
+    /// let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?;
     ///
     /// // Register the socket with `poll`
-    /// poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge()).unwrap();
+    /// poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge())?;
     ///
-    /// poll.deregister(&socket).unwrap();
+    /// poll.deregister(&socket)?;
     ///
     /// let mut events = Events::with_capacity(1024);
     ///
     /// // Set a timeout because this poll should never receive any events.
-    /// let n = poll.poll(&mut events, Some(Duration::from_secs(1))).unwrap();
+    /// let n = poll.poll(&mut events, Some(Duration::from_secs(1)))?;
     /// assert_eq!(0, n);
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     pub fn deregister<E: ?Sized>(&self, handle: &E) -> io::Result<()>
         where E: Evented
@@ -898,6 +946,8 @@
     /// A basic example -- establishing a `TcpStream` connection.
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Poll, Ready, PollOpt, Token};
     /// use mio::tcp::TcpStream;
     ///
@@ -905,9 +955,9 @@
     /// use std::thread;
     ///
     /// // Bind a server socket to connect to.
-    /// let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
-    /// let server = TcpListener::bind(&addr).unwrap();
-    /// let addr = server.local_addr().unwrap().clone();
+    /// let addr: SocketAddr = "127.0.0.1:0".parse()?;
+    /// let server = TcpListener::bind(&addr)?;
+    /// let addr = server.local_addr()?.clone();
     ///
     /// // Spawn a thread to accept the socket
     /// thread::spawn(move || {
@@ -915,28 +965,34 @@
     /// });
     ///
     /// // Construct a new `Poll` handle as well as the `Events` we'll store into
-    /// let poll = Poll::new().unwrap();
+    /// let poll = Poll::new()?;
     /// let mut events = Events::with_capacity(1024);
     ///
     /// // Connect the stream
-    /// let stream = TcpStream::connect(&addr).unwrap();
+    /// let stream = TcpStream::connect(&addr)?;
     ///
     /// // Register the stream with `Poll`
-    /// poll.register(&stream, Token(0), Ready::all(), PollOpt::edge()).unwrap();
+    /// poll.register(&stream, Token(0), Ready::all(), PollOpt::edge())?;
     ///
     /// // Wait for the socket to become ready. This has to happens in a loop to
     /// // handle spurious wakeups.
     /// loop {
-    ///     poll.poll(&mut events, None).unwrap();
+    ///     poll.poll(&mut events, None)?;
     ///
     ///     for event in &events {
     ///         if event.token() == Token(0) && event.readiness().is_writable() {
     ///             // The socket connected (probably, it could still be a spurious
     ///             // wakeup)
-    ///             return;
+    ///             return Ok(());
     ///         }
     ///     }
     /// }
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     ///
     /// [struct]: #
@@ -1162,21 +1218,29 @@
 /// # Examples
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Events, Poll};
 /// use std::time::Duration;
 ///
 /// let mut events = Events::with_capacity(1024);
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 ///
 /// assert_eq!(0, events.len());
 ///
 /// // Register `Evented` handles with `poll`
 ///
-/// poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
+/// poll.poll(&mut events, Some(Duration::from_millis(100)))?;
 ///
 /// for event in &events {
 ///     println!("event={:?}", event);
 /// }
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// [`Poll::poll`]: struct.Poll.html#method.poll
@@ -1193,19 +1257,27 @@
 /// # Examples
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Events, Poll};
 /// use std::time::Duration;
 ///
 /// let mut events = Events::with_capacity(1024);
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 ///
 /// // Register handles with `poll`
 ///
-/// poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
+/// poll.poll(&mut events, Some(Duration::from_millis(100)))?;
 ///
 /// for event in events.iter() {
 ///     println!("event={:?}", event);
 /// }
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// [`Events`]: struct.Events.html
@@ -1240,19 +1312,27 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Poll};
     /// use std::time::Duration;
     ///
     /// let mut events = Events::with_capacity(1024);
-    /// let poll = Poll::new().unwrap();
+    /// let poll = Poll::new()?;
     ///
     /// // Register handles with `poll`
     ///
-    /// let n = poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
+    /// let n = poll.poll(&mut events, Some(Duration::from_millis(100)))?;
     ///
     /// for i in 0..n {
     ///     println!("event={:?}", events.get(i).unwrap());
     /// }
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     pub fn get(&self, idx: usize) -> Option<Event> {
         self.inner.get(idx)
@@ -1306,19 +1386,27 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Poll};
     /// use std::time::Duration;
     ///
     /// let mut events = Events::with_capacity(1024);
-    /// let poll = Poll::new().unwrap();
+    /// let poll = Poll::new()?;
     ///
     /// // Register handles with `poll`
     ///
-    /// poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
+    /// poll.poll(&mut events, Some(Duration::from_millis(100)))?;
     ///
     /// for event in events.iter() {
     ///     println!("event={:?}", event);
     /// }
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     pub fn iter(&self) -> Iter {
         Iter {
@@ -1386,6 +1474,8 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Ready, Registration, Poll, PollOpt, Token};
     /// use std::thread;
     ///
@@ -1398,8 +1488,8 @@
     ///     set_readiness.set_readiness(Ready::readable());
     /// });
     ///
-    /// let poll = Poll::new().unwrap();
-    /// poll.register(&registration, Token(0), Ready::all(), PollOpt::edge()).unwrap();
+    /// let poll = Poll::new()?;
+    /// poll.register(&registration, Token(0), Ready::all(), PollOpt::edge())?;
     ///
     /// let mut events = Events::with_capacity(256);
     ///
@@ -1408,11 +1498,16 @@
     ///
     ///     for event in &events {
     ///         if event.token() == Token(0) && event.readiness().is_readable() {
-    ///             return;
+    ///             return Ok(());
     ///         }
     ///     }
     /// }
-    ///
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     /// [struct]: #
     /// [`Poll`]: struct.Poll.html
@@ -1541,14 +1636,22 @@
     /// # Examples
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Registration, Ready};
     ///
     /// let (registration, set_readiness) = Registration::new2();
     ///
     /// assert!(set_readiness.readiness().is_empty());
     ///
-    /// set_readiness.set_readiness(Ready::readable()).unwrap();
+    /// set_readiness.set_readiness(Ready::readable())?;
     /// assert!(set_readiness.readiness().is_readable());
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     pub fn readiness(&self) -> Ready {
         self.inner.readiness()
@@ -1573,28 +1676,36 @@
     /// work:
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Events, Registration, Ready, Poll, PollOpt, Token};
     ///
-    /// let poll = Poll::new().unwrap();
+    /// let poll = Poll::new()?;
     /// let (registration, set_readiness) = Registration::new2();
     ///
     /// poll.register(&registration,
     ///               Token(0),
     ///               Ready::readable(),
-    ///               PollOpt::edge()).unwrap();
+    ///               PollOpt::edge())?;
     ///
     /// // Set the readiness, then immediately poll to try to get the readiness
     /// // event
-    /// set_readiness.set_readiness(Ready::readable()).unwrap();
+    /// set_readiness.set_readiness(Ready::readable())?;
     ///
     /// let mut events = Events::with_capacity(1024);
-    /// poll.poll(&mut events, None).unwrap();
+    /// poll.poll(&mut events, None)?;
     ///
     /// // There is NO guarantee that the following will work. It is possible
     /// // that the readiness event will be delivered at a later time.
     /// let event = events.get(0).unwrap();
     /// assert_eq!(event.token(), Token(0));
     /// assert!(event.readiness().is_readable());
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     ///
     /// # Examples
@@ -1603,14 +1714,22 @@
     /// documentation.
     ///
     /// ```
+    /// # use std::error::Error;
+    /// # fn try_main() -> Result<(), Box<Error>> {
     /// use mio::{Registration, Ready};
     ///
     /// let (registration, set_readiness) = Registration::new2();
     ///
     /// assert!(set_readiness.readiness().is_empty());
     ///
-    /// set_readiness.set_readiness(Ready::readable()).unwrap();
+    /// set_readiness.set_readiness(Ready::readable())?;
     /// assert!(set_readiness.readiness().is_readable());
+    /// #     Ok(())
+    /// # }
+    /// #
+    /// # fn main() {
+    /// #     try_main().unwrap();
+    /// # }
     /// ```
     ///
     /// [`Registration`]: struct.Registration.html
diff --git a/src/sys/unix/eventedfd.rs b/src/sys/unix/eventedfd.rs
index 7ee2918..c40d5fe 100644
--- a/src/sys/unix/eventedfd.rs
+++ b/src/sys/unix/eventedfd.rs
@@ -29,6 +29,8 @@
 /// Basic usage
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Ready, Poll, PollOpt, Token};
 /// use mio::unix::EventedFd;
 ///
@@ -36,13 +38,19 @@
 /// use std::net::TcpListener;
 ///
 /// // Bind a std listener
-/// let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+/// let listener = TcpListener::bind("127.0.0.1:0")?;
 ///
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 ///
 /// // Register the listener
 /// poll.register(&EventedFd(&listener.as_raw_fd()),
-///              Token(0), Ready::readable(), PollOpt::edge()).unwrap();
+///              Token(0), Ready::readable(), PollOpt::edge())?;
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// Implementing `Evented` for a custom type backed by a `RawFd`.
diff --git a/src/sys/unix/ready.rs b/src/sys/unix/ready.rs
index 7c62492..ef454d0 100644
--- a/src/sys/unix/ready.rs
+++ b/src/sys/unix/ready.rs
@@ -63,20 +63,27 @@
 /// Registering readable and error interest on a socket
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Ready, Poll, PollOpt, Token};
 /// use mio::tcp::TcpStream;
 /// use mio::unix::UnixReady;
 ///
-/// let addr = "216.58.193.68:80".parse().unwrap();
-/// let socket = TcpStream::connect(&addr).unwrap();
+/// let addr = "216.58.193.68:80".parse()?;
+/// let socket = TcpStream::connect(&addr)?;
 ///
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 ///
 /// poll.register(&socket,
 ///               Token(0),
 ///               Ready::readable() | UnixReady::error(),
-///               PollOpt::edge()).unwrap();
-///
+///               PollOpt::edge())?;
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// [`Poll`]: struct.Poll.html
diff --git a/src/token.rs b/src/token.rs
index b31a31b..dd6ef40 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -11,6 +11,8 @@
 /// example, `HashMap` is used, but usually something like [`slab`] is better.
 ///
 /// ```
+/// # use std::error::Error;
+/// # fn try_main() -> Result<(), Box<Error>> {
 /// use mio::{Events, Ready, Poll, PollOpt, Token};
 /// use mio::tcp::TcpListener;
 ///
@@ -32,19 +34,19 @@
 /// let mut next_socket_index = 0;
 ///
 /// // The `Poll` instance
-/// let poll = Poll::new().unwrap();
+/// let poll = Poll::new()?;
 ///
 /// // Tcp listener
-/// let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
+/// let listener = TcpListener::bind(&"127.0.0.1:0".parse()?)?;
 ///
 /// // Register the listener
 /// poll.register(&listener,
 ///               LISTENER,
 ///               Ready::readable(),
-///               PollOpt::edge()).unwrap();
+///               PollOpt::edge())?;
 ///
 /// // Spawn a thread that will connect a bunch of sockets then close them
-/// let addr = listener.local_addr().unwrap();
+/// let addr = listener.local_addr()?;
 /// thread::spawn(move || {
 ///     use std::net::TcpStream;
 ///
@@ -64,7 +66,7 @@
 /// // The main event loop
 /// loop {
 ///     // Wait for events
-///     poll.poll(&mut events, None).unwrap();
+///     poll.poll(&mut events, None)?;
 ///
 ///     for event in &events {
 ///         match event.token() {
@@ -76,7 +78,7 @@
 ///                         Ok((socket, _)) => {
 ///                             // Shutdown the server
 ///                             if next_socket_index == MAX_SOCKETS {
-///                                 return;
+///                                 return Ok(());
 ///                             }
 ///
 ///                             // Get the token for the socket
@@ -87,7 +89,7 @@
 ///                             poll.register(&socket,
 ///                                          token,
 ///                                          Ready::readable(),
-///                                          PollOpt::edge()).unwrap();
+///                                          PollOpt::edge())?;
 ///
 ///                             // Store the socket
 ///                             sockets.insert(token, socket);
@@ -122,6 +124,12 @@
 ///         }
 ///     }
 /// }
+/// #     Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// #     try_main().unwrap();
+/// # }
 /// ```
 ///
 /// [`Evented`]: event/trait.Evented.html