NixResult -> nix::Result; NixError -> nix::Error

13 files changed, 100 insertions, 100 deletions

diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs
index 138680fe..a68a7b6f 100644
--- a/src/sys/epoll.rs
+++ b/src/sys/epoll.rs
@@ -1,7 +1,7 @@
 use std::fmt;
 use libc::c_int;
 use errno::Errno;
-use {NixError, NixResult, from_ffi};
+use {Error, Result, from_ffi};
 use fcntl::Fd;
 
 mod ffi {
@@ -102,30 +102,30 @@ pub struct EpollEvent {
 }
 
 #[inline]
-pub fn epoll_create() -> NixResult<Fd> {
+pub fn epoll_create() -> Result<Fd> {
     let res = unsafe { ffi::epoll_create(1024) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(res)
 }
 
 #[inline]
-pub fn epoll_ctl(epfd: Fd, op: EpollOp, fd: Fd, event: &EpollEvent) -> NixResult<()> {
+pub fn epoll_ctl(epfd: Fd, op: EpollOp, fd: Fd, event: &EpollEvent) -> Result<()> {
     let res = unsafe { ffi::epoll_ctl(epfd, op as c_int, fd, event as *const EpollEvent) };
     from_ffi(res)
 }
 
 #[inline]
-pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: usize) -> NixResult<usize> {
+pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: usize) -> Result<usize> {
     let res = unsafe {
         ffi::epoll_wait(epfd, events.as_mut_ptr(), events.len() as c_int, timeout_ms as c_int)
     };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(res as usize)
diff --git a/src/sys/event.rs b/src/sys/event.rs
index efe54b19..9a0ede1e 100644
--- a/src/sys/event.rs
+++ b/src/sys/event.rs
@@ -5,7 +5,7 @@ use libc::{timespec, time_t, c_int, c_long, uintptr_t};
 use errno::Errno;
 use fcntl::Fd;
 use std::fmt;
-use {NixError, NixResult};
+use {Error, Result};
 
 pub use self::ffi::kevent as KEvent;
 
@@ -159,11 +159,11 @@ bitflags!(
 pub const EV_POLL: EventFlag = EV_FLAG0;
 pub const EV_OOBAND: EventFlag = EV_FLAG1;
 
-pub fn kqueue() -> NixResult<Fd> {
+pub fn kqueue() -> Result<Fd> {
     let res = unsafe { ffi::kqueue() };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(res)
@@ -172,7 +172,7 @@ pub fn kqueue() -> NixResult<Fd> {
 pub fn kevent(kq: Fd,
               changelist: &[KEvent],
               eventlist: &mut [KEvent],
-              timeout_ms: usize) -> NixResult<usize> {
+              timeout_ms: usize) -> Result<usize> {
 
     // Convert ms to timespec
     let timeout = timespec {
@@ -191,7 +191,7 @@ pub fn kevent(kq: Fd,
     };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     return Ok(res as usize)
diff --git a/src/sys/eventfd.rs b/src/sys/eventfd.rs
index 07162f85..f072405f 100644
--- a/src/sys/eventfd.rs
+++ b/src/sys/eventfd.rs
@@ -2,7 +2,7 @@ use std::mem;
 use libc::{c_int, c_uint};
 use errno::Errno;
 use fcntl::Fd;
-use {NixError, NixResult};
+use {Error, Result};
 
 bitflags!(
     flags EventFdFlag: c_int {
@@ -12,7 +12,7 @@ bitflags!(
     }
 );
 
-pub fn eventfd(initval: usize, flags: EventFdFlag) -> NixResult<Fd> {
+pub fn eventfd(initval: usize, flags: EventFdFlag) -> Result<Fd> {
     type F = unsafe extern "C" fn(initval: c_uint, flags: c_int) -> c_int;
 
     extern {
@@ -30,7 +30,7 @@ pub fn eventfd(initval: usize, flags: EventFdFlag) -> NixResult<Fd> {
     };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(res)
diff --git a/src/sys/ioctl.rs b/src/sys/ioctl.rs
index 516b29bc..5003a4f6 100644
--- a/src/sys/ioctl.rs
+++ b/src/sys/ioctl.rs
@@ -1,6 +1,6 @@
 use libc;
 use fcntl::Fd;
-use {NixResult, from_ffi};
+use {Result, from_ffi};
 
 pub use self::ffi::Winsize;
 pub use self::IoctlArg::*;
@@ -34,7 +34,7 @@ pub enum IoctlArg<'a> {
     TIOCGWINSZ(&'a mut Winsize)
 }
 
-pub fn ioctl(fd: Fd, arg: IoctlArg) -> NixResult<()> {
+pub fn ioctl(fd: Fd, arg: IoctlArg) -> Result<()> {
     match arg {
         TIOCGWINSZ(&mut ref winsize) => {
             from_ffi(unsafe {
diff --git a/src/sys/mman.rs b/src/sys/mman.rs
index 60171a9e..a905744d 100644
--- a/src/sys/mman.rs
+++ b/src/sys/mman.rs
@@ -1,4 +1,4 @@
-use {NixError, NixResult, NixPath, AsExtStr};
+use {Error, Result, NixPath, AsExtStr};
 use errno::Errno;
 use fcntl::{Fd, OFlag};
 use libc::{c_void, size_t, off_t, mode_t};
@@ -128,54 +128,54 @@ mod ffi {
     }
 }
 
-pub unsafe fn mlock(addr: *const c_void, length: size_t) -> NixResult<()> {
+pub unsafe fn mlock(addr: *const c_void, length: size_t) -> Result<()> {
     match ffi::mlock(addr, length) {
         0 => Ok(()),
-        _ => Err(NixError::Sys(Errno::last()))
+        _ => Err(Error::Sys(Errno::last()))
     }
 }
 
-pub fn munlock(addr: *const c_void, length: size_t) -> NixResult<()> {
+pub fn munlock(addr: *const c_void, length: size_t) -> Result<()> {
     match unsafe { ffi::munlock(addr, length) } {
         0 => Ok(()),
-        _ => Err(NixError::Sys(Errno::last()))
+        _ => Err(Error::Sys(Errno::last()))
     }
 }
 
 /// Calls to mmap are inherently unsafe, so they must be made in an unsafe block. Typically
 /// a higher-level abstraction will hide the unsafe interactions with the mmap'd region.
-pub fn mmap(addr: *mut c_void, length: size_t, prot: MmapProt, flags: MmapFlag, fd: Fd, offset: off_t) -> NixResult<*mut c_void> {
+pub fn mmap(addr: *mut c_void, length: size_t, prot: MmapProt, flags: MmapFlag, fd: Fd, offset: off_t) -> Result<*mut c_void> {
     let ret = unsafe { ffi::mmap(addr, length, prot, flags, fd, offset) };
 
     if ret as isize == MAP_FAILED  {
-        Err(NixError::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
     } else {
         Ok(ret)
     }
 }
 
-pub fn munmap(addr: *mut c_void, len: size_t) -> NixResult<()> {
+pub fn munmap(addr: *mut c_void, len: size_t) -> Result<()> {
     match unsafe { ffi::munmap(addr, len) } {
         0 => Ok(()),
-        _ => Err(NixError::Sys(Errno::last()))
+        _ => Err(Error::Sys(Errno::last()))
     }
 }
 
-pub fn madvise(addr: *const c_void, length: size_t, advise: MmapAdvise) -> NixResult<()> {
+pub fn madvise(addr: *const c_void, length: size_t, advise: MmapAdvise) -> Result<()> {
     match unsafe { ffi::madvise(addr, length, advise) } {
         0 => Ok(()),
-        _ => Err(NixError::Sys(Errno::last()))
+        _ => Err(Error::Sys(Errno::last()))
     }
 }
 
-pub fn msync(addr: *const c_void, length: size_t, flags: MmapSync) -> NixResult<()> {
+pub fn msync(addr: *const c_void, length: size_t, flags: MmapSync) -> Result<()> {
     match unsafe { ffi::msync(addr, length, flags) } {
         0 => Ok(()),
-        _ => Err(NixError::Sys(Errno::last()))
+        _ => Err(Error::Sys(Errno::last()))
     }
 }
 
-pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> NixResult<Fd> {
+pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> Result<Fd> {
     let ret = try!(name.with_nix_path(|osstr| {
         unsafe {
             ffi::shm_open(osstr.as_ext_str(), flag.bits(), mode.bits() as mode_t)
@@ -183,19 +183,19 @@ pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> NixRe
     }));
 
     if ret < 0 {
-        Err(NixError::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
     } else {
         Ok(ret)
     }
 }
 
-pub fn shm_unlink<P: ?Sized + NixPath>(name: &P) -> NixResult<()> {
+pub fn shm_unlink<P: ?Sized + NixPath>(name: &P) -> Result<()> {
     let ret = try!(name.with_nix_path(|osstr| {
         unsafe { ffi::shm_unlink(osstr.as_ext_str()) }
     }));
 
     if ret < 0 {
-        Err(NixError::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
     } else {
         Ok(())
     }
diff --git a/src/sys/signal.rs b/src/sys/signal.rs
index e63cff13..5dd974cc 100644
--- a/src/sys/signal.rs
+++ b/src/sys/signal.rs
@@ -4,7 +4,7 @@
 use libc;
 use errno::Errno;
 use core::mem;
-use {NixError, NixResult};
+use {Error, Result};
 
 pub use libc::consts::os::posix88::{
     SIGHUP,   // 1
@@ -312,21 +312,21 @@ impl SigSet {
         SigSet { sigset: sigset }
     }
 
-    pub fn add(&mut self, signum: SigNum) -> NixResult<()> {
+    pub fn add(&mut self, signum: SigNum) -> Result<()> {
         let res = unsafe { ffi::sigaddset(&mut self.sigset as *mut sigset_t, signum) };
 
         if res < 0 {
-            return Err(NixError::Sys(Errno::last()));
+            return Err(Error::Sys(Errno::last()));
         }
 
         Ok(())
     }
 
-    pub fn remove(&mut self, signum: SigNum) -> NixResult<()> {
+    pub fn remove(&mut self, signum: SigNum) -> Result<()> {
         let res = unsafe { ffi::sigdelset(&mut self.sigset as *mut sigset_t, signum) };
 
         if res < 0 {
-            return Err(NixError::Sys(Errno::last()));
+            return Err(Error::Sys(Errno::last()));
         }
 
         Ok(())
@@ -350,7 +350,7 @@ impl SigAction {
     }
 }
 
-pub fn sigaction(signum: SigNum, sigaction: &SigAction) -> NixResult<SigAction> {
+pub fn sigaction(signum: SigNum, sigaction: &SigAction) -> Result<SigAction> {
     let mut oldact = unsafe { mem::uninitialized::<sigaction_t>() };
 
     let res = unsafe {
@@ -358,17 +358,17 @@ pub fn sigaction(signum: SigNum, sigaction: &SigAction) -> NixResult<SigAction>
     };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(SigAction { sigaction: oldact })
 }
 
-pub fn kill(pid: libc::pid_t, signum: SigNum) -> NixResult<()> {
+pub fn kill(pid: libc::pid_t, signum: SigNum) -> Result<()> {
     let res = unsafe { ffi::kill(pid, signum) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(())
diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs
index 5ff65594..46c8d920 100644
--- a/src/sys/socket/addr.rs
+++ b/src/sys/socket/addr.rs
@@ -1,4 +1,4 @@
-use {NixResult, NixError, NixPath};
+use {Result, Error, NixPath};
 use super::{consts, sa_family_t};
 use errno::Errno;
 use libc;
@@ -334,7 +334,7 @@ impl fmt::Display for Ipv6Addr {
 pub struct UnixAddr(pub libc::sockaddr_un);
 
 impl UnixAddr {
-    pub fn new<P: ?Sized + NixPath>(path: &P) -> NixResult<UnixAddr> {
+    pub fn new<P: ?Sized + NixPath>(path: &P) -> Result<UnixAddr> {
         try!(path.with_nix_path(|osstr| {
             unsafe {
                 let bytes = osstr.as_bytes();
@@ -345,7 +345,7 @@ impl UnixAddr {
                 };
 
                 if bytes.len() >= ret.sun_path.len() {
-                    return Err(NixError::Sys(Errno::ENAMETOOLONG));
+                    return Err(Error::Sys(Errno::ENAMETOOLONG));
                 }
 
                 ptr::copy(
@@ -413,7 +413,7 @@ impl SockAddr {
         SockAddr::Inet(addr)
     }
 
-    pub fn new_unix<P: ?Sized + NixPath>(path: &P) -> NixResult<SockAddr> {
+    pub fn new_unix<P: ?Sized + NixPath>(path: &P) -> Result<SockAddr> {
         Ok(SockAddr::Unix(try!(UnixAddr::new(path))))
     }
 
diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs
index 16cf0dfc..33d58301 100644
--- a/src/sys/socket/mod.rs
+++ b/src/sys/socket/mod.rs
@@ -1,7 +1,7 @@
 //! Socket interface functions
 //!
 //! [Further reading](http://man7.org/linux/man-pages/man7/socket.7.html)
-use {NixError, NixResult, from_ffi};
+use {Error, Result, from_ffi};
 use errno::Errno;
 use features;
 use fcntl::{fcntl, FD_CLOEXEC, O_NONBLOCK};
@@ -78,7 +78,7 @@ bitflags!(
 /// Create an endpoint for communication
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/socket.2.html)
-pub fn socket(domain: AddressFamily, ty: SockType, flags: SockFlag) -> NixResult<Fd> {
+pub fn socket(domain: AddressFamily, ty: SockType, flags: SockFlag) -> Result<Fd> {
     let mut ty = ty as c_int;
     let feat_atomic = features::socket_atomic_cloexec();
 
@@ -90,7 +90,7 @@ pub fn socket(domain: AddressFamily, ty: SockType, flags: SockFlag) -> NixResult
     let res = unsafe { ffi::socket(domain as c_int, ty, 0) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     if !feat_atomic {
@@ -109,7 +109,7 @@ pub fn socket(domain: AddressFamily, ty: SockType, flags: SockFlag) -> NixResult
 /// Listen for connections on a socket
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/listen.2.html)
-pub fn listen(sockfd: Fd, backlog: usize) -> NixResult<()> {
+pub fn listen(sockfd: Fd, backlog: usize) -> Result<()> {
     let res = unsafe { ffi::listen(sockfd, backlog as c_int) };
     from_ffi(res)
 }
@@ -117,7 +117,7 @@ pub fn listen(sockfd: Fd, backlog: usize) -> NixResult<()> {
 /// Bind a name to a socket
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/bind.2.html)
-pub fn bind(fd: Fd, addr: &SockAddr) -> NixResult<()> {
+pub fn bind(fd: Fd, addr: &SockAddr) -> Result<()> {
     let res = unsafe {
         let (ptr, len) = addr.as_ffi_pair();
         ffi::bind(fd, ptr, len)
@@ -129,11 +129,11 @@ pub fn bind(fd: Fd, addr: &SockAddr) -> NixResult<()> {
 /// Accept a connection on a socket
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/accept.2.html)
-pub fn accept(sockfd: Fd) -> NixResult<Fd> {
+pub fn accept(sockfd: Fd) -> Result<Fd> {
     let res = unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(res)
@@ -143,7 +143,7 @@ pub fn accept(sockfd: Fd) -> NixResult<Fd> {
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/accept.2.html)
 #[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "android")))]
-pub fn accept4(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
+pub fn accept4(sockfd: Fd, flags: SockFlag) -> Result<Fd> {
     use libc::sockaddr;
 
     type F = unsafe extern "C" fn(c_int, *mut sockaddr, *mut socklen_t, c_int) -> c_int;
@@ -160,7 +160,7 @@ pub fn accept4(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
         };
 
         if res < 0 {
-            return Err(NixError::Sys(Errno::last()));
+            return Err(Error::Sys(Errno::last()));
         }
 
         Ok(res)
@@ -173,16 +173,16 @@ pub fn accept4(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/accept.2.html)
 #[cfg(any(target_os = "macos", target_os = "ios", target_os = "android"))]
-pub fn accept4(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
+pub fn accept4(sockfd: Fd, flags: SockFlag) -> Result<Fd> {
     accept4_polyfill(sockfd, flags)
 }
 
 #[inline]
-fn accept4_polyfill(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
+fn accept4_polyfill(sockfd: Fd, flags: SockFlag) -> Result<Fd> {
     let res =  unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     if flags.contains(SOCK_CLOEXEC) {
@@ -199,7 +199,7 @@ fn accept4_polyfill(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
 /// Initiate a connection on a socket
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/connect.2.html)
-pub fn connect(fd: Fd, addr: &SockAddr) -> NixResult<()> {
+pub fn connect(fd: Fd, addr: &SockAddr) -> Result<()> {
     let res = unsafe {
         let (ptr, len) = addr.as_ffi_pair();
         ffi::connect(fd, ptr, len)
@@ -212,7 +212,7 @@ pub fn connect(fd: Fd, addr: &SockAddr) -> NixResult<()> {
 /// the number of bytes read and the socket address of the sender.
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/recvmsg.2.html)
-pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> NixResult<(usize, SockAddr)> {
+pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> Result<(usize, SockAddr)> {
     unsafe {
         let addr: sockaddr_storage = mem::zeroed();
         let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
@@ -226,7 +226,7 @@ pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> NixResult<(usize, SockAddr)> {
             &mut len as *mut socklen_t);
 
         if ret < 0 {
-            return Err(NixError::last());
+            return Err(Error::last());
         }
 
         sockaddr_storage_to_addr(&addr, len as usize)
@@ -234,14 +234,14 @@ pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> NixResult<(usize, SockAddr)> {
     }
 }
 
-pub fn sendto(fd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -> NixResult<usize> {
+pub fn sendto(fd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -> Result<usize> {
     let ret = unsafe {
         let (ptr, len) = addr.as_ffi_pair();
         ffi::sendto(fd, buf.as_ptr() as *const c_void, buf.len() as size_t, flags, ptr, len)
     };
 
     if ret < 0 {
-        Err(NixError::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
     } else {
         Ok(ret as usize)
     }
@@ -284,30 +284,30 @@ pub trait SockOpt : Copy + fmt::Debug {
     type Set;
 
     #[doc(hidden)]
-    fn get(&self, fd: Fd, level: c_int) -> NixResult<Self::Get>;
+    fn get(&self, fd: Fd, level: c_int) -> Result<Self::Get>;
 
     #[doc(hidden)]
-    fn set(&self, fd: Fd, level: c_int, val: Self::Set) -> NixResult<()>;
+    fn set(&self, fd: Fd, level: c_int, val: Self::Set) -> Result<()>;
 }
 
 /// Get the current value for the requested socket option
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/setsockopt.2.html)
-pub fn getsockopt<O: SockOpt>(fd: Fd, level: SockLevel, opt: O) -> NixResult<O::Get> {
+pub fn getsockopt<O: SockOpt>(fd: Fd, level: SockLevel, opt: O) -> Result<O::Get> {
     opt.get(fd, level as c_int)
 }
 
 /// Sets the value for the requested socket option
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/setsockopt.2.html)
-pub fn setsockopt<O: SockOpt>(fd: Fd, level: SockLevel, opt: O, val: O::Set) -> NixResult<()> {
+pub fn setsockopt<O: SockOpt>(fd: Fd, level: SockLevel, opt: O, val: O::Set) -> Result<()> {
     opt.set(fd, level as c_int, val)
 }
 
 /// Get the address of the peer connected to the socket `fd`.
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/getpeername.2.html)
-pub fn getpeername(fd: Fd) -> NixResult<SockAddr> {
+pub fn getpeername(fd: Fd) -> Result<SockAddr> {
     unsafe {
         let addr: sockaddr_storage = mem::uninitialized();
         let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
@@ -315,7 +315,7 @@ pub fn getpeername(fd: Fd) -> NixResult<SockAddr> {
         let ret = ffi::getpeername(fd, mem::transmute(&addr), &mut len);
 
         if ret < 0 {
-            return Err(NixError::last());
+            return Err(Error::last());
         }
 
         sockaddr_storage_to_addr(&addr, len as usize)
@@ -325,7 +325,7 @@ pub fn getpeername(fd: Fd) -> NixResult<SockAddr> {
 /// Get the current address to which the socket `fd` is bound.
 ///
 /// [Further reading](http://man7.org/linux/man-pages/man2/getsockname.2.html)
-pub fn getsockname(fd: Fd) -> NixResult<SockAddr> {
+pub fn getsockname(fd: Fd) -> Result<SockAddr> {
     unsafe {
         let addr: sockaddr_storage = mem::uninitialized();
         let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
@@ -333,7 +333,7 @@ pub fn getsockname(fd: Fd) -> NixResult<SockAddr> {
         let ret = ffi::getsockname(fd, mem::transmute(&addr), &mut len);
 
         if ret < 0 {
-            return Err(NixError::last());
+            return Err(Error::last());
         }
 
         sockaddr_storage_to_addr(&addr, len as usize)
@@ -342,7 +342,7 @@ pub fn getsockname(fd: Fd) -> NixResult<SockAddr> {
 
 pub unsafe fn sockaddr_storage_to_addr(
     addr: &sockaddr_storage,
-    len: usize) -> NixResult<SockAddr> {
+    len: usize) -> Result<SockAddr> {
 
     match addr.ss_family as c_int {
         consts::AF_INET => {
diff --git a/src/sys/socket/sockopt.rs b/src/sys/socket/sockopt.rs
index be3ff8e7..9a06d198 100644
--- a/src/sys/socket/sockopt.rs
+++ b/src/sys/socket/sockopt.rs
@@ -1,4 +1,4 @@
-use {NixResult, NixError, from_ffi};
+use {Result, Error, from_ffi};
 use super::{ffi, consts, SockOpt};
 use errno::Errno;
 use sys::time::TimeVal;
@@ -29,7 +29,7 @@ macro_rules! sockopt_impl {
             type Get = $get_ty;
             type Set = $set_ty;
 
-            fn get(&self, fd: Fd, level: c_int) -> NixResult<$get_ty> {
+            fn get(&self, fd: Fd, level: c_int) -> Result<$get_ty> {
                 unsafe {
                     let mut getter: $getter = Get::blank();
 
@@ -39,14 +39,14 @@ macro_rules! sockopt_impl {
                         getter.ffi_len());
 
                     if res < 0 {
-                        return Err(NixError::Sys(Errno::last()));
+                        return Err(Error::Sys(Errno::last()));
                     }
 
                     Ok(getter.unwrap())
                 }
             }
 
-            fn set(&self, fd: Fd, level: c_int, val: $set_ty) -> NixResult<()> {
+            fn set(&self, fd: Fd, level: c_int, val: $set_ty) -> Result<()> {
                 unsafe {
                     let setter: $setter = Set::new(val);
 
diff --git a/src/sys/stat.rs b/src/sys/stat.rs
index f51fec4a..d98d20ec 100644
--- a/src/sys/stat.rs
+++ b/src/sys/stat.rs
@@ -1,7 +1,7 @@
 pub use libc::dev_t;
 pub use libc::stat as FileStat;
 
-use {NixError, NixResult, NixPath, AsExtStr,from_ffi};
+use {Error, Result, NixPath, AsExtStr,from_ffi};
 use errno::Errno;
 use fcntl::Fd;
 use libc::mode_t;
@@ -57,7 +57,7 @@ impl fmt::Debug for SFlag {
     }
 }
 
-pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t) -> NixResult<()> {
+pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t) -> Result<()> {
     let res = try!(path.with_nix_path(|osstr| {
         unsafe {
             ffi::mknod(osstr.as_ext_str(), kind.bits | perm.bits() as mode_t, dev)
@@ -79,7 +79,7 @@ pub fn umask(mode: Mode) -> Mode {
     Mode::from_bits(prev).expect("[BUG] umask returned invalid Mode")
 }
 
-pub fn stat<P: ?Sized + NixPath>(path: &P) -> NixResult<FileStat> {
+pub fn stat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
     let mut dst = unsafe { mem::uninitialized() };
     let res = try!(path.with_nix_path(|osstr| {
         unsafe {
@@ -88,18 +88,18 @@ pub fn stat<P: ?Sized + NixPath>(path: &P) -> NixResult<FileStat> {
     }));
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(dst)
 }
 
-pub fn fstat(fd: Fd) -> NixResult<FileStat> {
+pub fn fstat(fd: Fd) -> Result<FileStat> {
     let mut dst = unsafe { mem::uninitialized() };
     let res = unsafe { ffi::fstat(fd, &mut dst as *mut FileStat) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(dst)
diff --git a/src/sys/termios.rs b/src/sys/termios.rs
index 7ef2ca57..c5758fe0 100644
--- a/src/sys/termios.rs
+++ b/src/sys/termios.rs
@@ -2,7 +2,7 @@ use errno::Errno;
 use fcntl::Fd;
 use libc::c_int;
 use std::mem;
-use {NixError, NixResult, from_ffi};
+use {Error, Result, from_ffi};
 
 pub use self::ffi::consts::*;
 pub use self::ffi::consts::SetArg::*;
@@ -421,19 +421,19 @@ pub fn cfgetospeed(termios: &Termios) -> speed_t {
     }
 }
 
-pub fn cfsetispeed(termios: &mut Termios, speed: speed_t) -> NixResult<()> {
+pub fn cfsetispeed(termios: &mut Termios, speed: speed_t) -> Result<()> {
     from_ffi(unsafe {
         ffi::cfsetispeed(termios, speed)
     })
 }
 
-pub fn cfsetospeed(termios: &mut Termios, speed: speed_t) -> NixResult<()> {
+pub fn cfsetospeed(termios: &mut Termios, speed: speed_t) -> Result<()> {
     from_ffi(unsafe {
         ffi::cfsetospeed(termios, speed)
     })
 }
 
-pub fn tcgetattr(fd: Fd) -> NixResult<Termios> {
+pub fn tcgetattr(fd: Fd) -> Result<Termios> {
     let mut termios = unsafe { mem::uninitialized() };
 
     let res = unsafe {
@@ -441,7 +441,7 @@ pub fn tcgetattr(fd: Fd) -> NixResult<Termios> {
     };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     Ok(termios)
@@ -449,31 +449,31 @@ pub fn tcgetattr(fd: Fd) -> NixResult<Termios> {
 
 pub fn tcsetattr(fd: Fd,
                  actions: SetArg,
-                 termios: &Termios) -> NixResult<()> {
+                 termios: &Termios) -> Result<()> {
     from_ffi(unsafe {
         ffi::tcsetattr(fd, actions as c_int, termios)
     })
 }
 
-pub fn tcdrain(fd: Fd) -> NixResult<()> {
+pub fn tcdrain(fd: Fd) -> Result<()> {
     from_ffi(unsafe {
         ffi::tcdrain(fd)
     })
 }
 
-pub fn tcflow(fd: Fd, action: FlowArg) -> NixResult<()> {
+pub fn tcflow(fd: Fd, action: FlowArg) -> Result<()> {
     from_ffi(unsafe {
         ffi::tcflow(fd, action as c_int)
     })
 }
 
-pub fn tcflush(fd: Fd, action: FlushArg) -> NixResult<()> {
+pub fn tcflush(fd: Fd, action: FlushArg) -> Result<()> {
     from_ffi(unsafe {
         ffi::tcflush(fd, action as c_int)
     })
 }
 
-pub fn tcsendbreak(fd: Fd, action: c_int) -> NixResult<()> {
+pub fn tcsendbreak(fd: Fd, action: c_int) -> Result<()> {
     from_ffi(unsafe {
         ffi::tcsendbreak(fd, action)
     })
diff --git a/src/sys/uio.rs b/src/sys/uio.rs
index 0d2072b9..62b1819b 100644
--- a/src/sys/uio.rs
+++ b/src/sys/uio.rs
@@ -1,7 +1,7 @@
 // Silence invalid warnings due to rust-lang/rust#16719
 #![allow(improper_ctypes)]
 
-use {NixResult, NixError};
+use {Result, Error};
 use errno::Errno;
 use fcntl::Fd;
 use libc::{c_int, c_void, size_t};
@@ -23,20 +23,20 @@ mod ffi {
     }
 }
 
-pub fn writev(fd: Fd, iov: &[IoVec<&[u8]>]) -> NixResult<usize> {
+pub fn writev(fd: Fd, iov: &[IoVec<&[u8]>]) -> Result<usize> {
     let res = unsafe { ffi::writev(fd, iov.as_ptr(), iov.len() as c_int) };
 
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     return Ok(res as usize)
 }
 
-pub fn readv(fd: Fd, iov: &mut [IoVec<&mut [u8]>]) -> NixResult<usize> {
+pub fn readv(fd: Fd, iov: &mut [IoVec<&mut [u8]>]) -> Result<usize> {
     let res = unsafe { ffi::readv(fd, iov.as_ptr(), iov.len() as c_int) };
     if res < 0 {
-        return Err(NixError::Sys(Errno::last()));
+        return Err(Error::Sys(Errno::last()));
     }
 
     return Ok(res as usize)
diff --git a/src/sys/wait.rs b/src/sys/wait.rs
index b07c68b5..6772dd90 100644
--- a/src/sys/wait.rs
+++ b/src/sys/wait.rs
@@ -1,6 +1,6 @@
 use libc::{pid_t, c_int};
 use errno::Errno;
-use {NixError, NixResult};
+use {Error, Result};
 
 mod ffi {
     use libc::{pid_t, c_int};
@@ -22,7 +22,7 @@ pub enum WaitStatus {
     StillAlive
 }
 
-pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> NixResult<WaitStatus> {
+pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> Result<WaitStatus> {
     use self::WaitStatus::*;
 
     let mut status: i32 = 0;
@@ -35,7 +35,7 @@ pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> NixResult<WaitStatus
     let res = unsafe { ffi::waitpid(pid as pid_t, &mut status as *mut c_int, option_bits) };
 
     if res < 0 {
-        Err(NixError::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
     } else if res == 0 {
         Ok(StillAlive)
     } else {