diff --git a/src/ed25519.rs b/src/ed25519.rs
index 9f000c7..6938374 100644
--- a/src/ed25519.rs
+++ b/src/ed25519.rs
@@ -36,16 +36,16 @@ use curve25519_dalek::edwards::CompressedEdwardsY;
 use curve25519_dalek::edwards::EdwardsPoint;
 use curve25519_dalek::scalar::Scalar;
 
-pub use constants::*;
-pub use errors::*;
-pub use signature::*;
+pub use crate::constants::*;
+pub use crate::errors::*;
+pub use crate::signature::*;
 
 /// An EdDSA secret key.
 #[derive(Default)] // we derive Default in order to use the clear() method in Drop
 pub struct SecretKey(pub (crate) [u8; SECRET_KEY_LENGTH]);
 
 impl Debug for SecretKey {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
         write!(f, "SecretKey: {:?}", &self.0[..])
     }
 }
@@ -198,7 +198,7 @@ impl<'d> Deserialize<'d> for SecretKey {
         impl<'d> Visitor<'d> for SecretKeyVisitor {
             type Value = SecretKey;
 
-            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 formatter.write_str("An ed25519 secret key as 32 bytes, as specified in RFC8032.")
             }
 
@@ -528,7 +528,7 @@ impl<'d> Deserialize<'d> for ExpandedSecretKey {
         impl<'d> Visitor<'d> for ExpandedSecretKeyVisitor {
             type Value = ExpandedSecretKey;
 
-            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 formatter.write_str("An ed25519 expanded secret key as 64 bytes, as specified in RFC8032.")
             }
 
@@ -548,7 +548,7 @@ pub struct PublicKey(
 );
 
 impl Debug for PublicKey {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
         write!(f, "PublicKey({:?}), {:?})", self.0, self.1)
     }
 }
@@ -880,7 +880,7 @@ impl<'d> Deserialize<'d> for PublicKey {
         impl<'d> Visitor<'d> for PublicKeyVisitor {
             type Value = PublicKey;
 
-            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 formatter.write_str("An ed25519 public key as a 32-byte compressed point, as specified in RFC8032")
             }
 
@@ -1202,7 +1202,7 @@ impl<'d> Deserialize<'d> for Keypair {
         impl<'d> Visitor<'d> for KeypairVisitor {
             type Value = Keypair;
 
-            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 formatter.write_str("An ed25519 keypair, 64 bytes in total where the secret key is \
                                      the first 32 bytes and is in unexpanded form, and the second \
                                      32 bytes is a compressed point for a public key.")
diff --git a/src/errors.rs b/src/errors.rs
index bf568a6..f531849 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -33,7 +33,7 @@ pub (crate) enum InternalError {
 }
 
 impl Display for InternalError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             InternalError::PointDecompressionError
                 => write!(f, "Cannot decompress Edwards point"),
@@ -67,13 +67,13 @@ impl ::failure::Fail for InternalError {}
 pub struct SignatureError(pub (crate) InternalError);
 
 impl Display for SignatureError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 
 impl ::failure::Fail for SignatureError {
-    fn cause(&self) -> Option<&::failure::Fail> {
+    fn cause(&self) -> Option<&dyn (::failure::Fail)> {
         Some(&self.0)
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index dff7e27..462ae40 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -238,6 +238,9 @@
 //! ```
 
 #![no_std]
+#![warn(future_incompatible)]
+#![warn(rust_2018_compatibility)]
+#![warn(rust_2018_idioms)]
 #![deny(missing_docs)] // refuse to compile if documentation is missing
 
 extern crate clear_on_drop;
@@ -251,15 +254,9 @@ extern crate std;
 
 extern crate sha2;
 
-#[cfg(test)]
-extern crate hex;
-
 #[cfg(feature = "serde")]
 extern crate serde;
 
-#[cfg(all(test, feature = "serde"))]
-extern crate bincode;
-
 mod constants;
 mod ed25519;
 mod signature;
@@ -267,5 +264,4 @@ mod signature;
 pub mod errors;
 
 // Export everything public in ed25519.
-pub use ed25519::*;
-pub use errors::*;
+pub use crate::ed25519::*;
diff --git a/src/signature.rs b/src/signature.rs
index f2f2316..d93b572 100644
--- a/src/signature.rs
+++ b/src/signature.rs
@@ -23,8 +23,8 @@ use serde::de::Error as SerdeError;
 #[cfg(feature = "serde")]
 use serde::de::Visitor;
 
-use constants::*;
-use errors::*;
+use crate::constants::*;
+use crate::errors::*;
 
 /// An ed25519 signature.
 ///
@@ -64,7 +64,7 @@ impl Clone for Signature {
 }
 
 impl Debug for Signature {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
         write!(f, "Signature( R: {:?}, s: {:?} )", &self.R, &self.s)
     }
 }
@@ -116,7 +116,7 @@ impl<'d> Deserialize<'d> for Signature {
         impl<'d> Visitor<'d> for SignatureVisitor {
             type Value = Signature;
 
-            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 formatter.write_str("An ed25519 signature as 64 bytes, as specified in RFC8032.")
             }