diff --git a/.travis.yml b/.travis.yml
index 5b40c48..fc5a566 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,21 +10,12 @@
         - cargo test --features raw_value
         - cargo test --features unbounded_depth
 
-    - rust: 1.15.0
-      script:
-        # preserve_order is not supported on 1.15.0
-        - cargo build --manifest-path tests/crate/Cargo.toml
-        - cargo build --manifest-path tests/crate/Cargo.toml --features arbitrary_precision
-
-    - rust: 1.18.0
-      script:
-        - cargo build --manifest-path tests/crate/Cargo.toml
-        - cargo build --manifest-path tests/crate/Cargo.toml --features preserve_order
-        - cargo build --manifest-path tests/crate/Cargo.toml --features arbitrary_precision
-
     - rust: stable
     - rust: beta
     - rust: 1.31.0
+    - rust: 1.36.0
+      script:
+        - cargo check --manifest-path tests/crate/Cargo.toml --no-default-features --features alloc
 
     - rust: nightly
       name: Clippy
diff --git a/Cargo.toml b/Cargo.toml
index 20a6b76..3571a71 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "serde_jsonrc"
-version = "0.1.1" # remember to update html_root_url
+version = "0.1.2" # remember to update html_root_url
 authors = [
     "Michael Bolin <bolinfest@gmail.com>",
     "Erick Tryzelaar <erick.tryzelaar@gmail.com>",
@@ -14,11 +14,12 @@
 categories = ["encoding"]
 readme = "README.md"
 include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+edition = "2018"
 
 [dependencies]
-serde = "1.0.60"
+serde = { version = "1.0.60", default-features = false }
 indexmap = { version = "1.2", optional = true }
-itoa = "0.4.3"
+itoa = { version = "0.4.3", default-features = false }
 ryu = "1.0"
 
 [dev-dependencies]
@@ -27,7 +28,7 @@
 serde_bytes = "0.11"
 serde_derive = "1.0"
 serde_stacker = "0.1"
-trybuild = "1.0"
+trybuild = { version = "1.0.19", features = ["diff"] }
 
 [workspace]
 members = ["tests/crate"]
@@ -42,7 +43,15 @@
 ### FEATURES #################################################################
 
 [features]
-default = []
+default = ["std"]
+
+std = ["serde/std"]
+
+# Provide integration for heap-allocated collections without depending on the
+# rest of the Rust standard library.
+# NOTE: Disabling both `std` *and* `alloc` features is not supported yet.
+# Available on Rust 1.36+.
+alloc = ["serde/alloc"]
 
 # Use a different representation for the map type of serde_jsonrc::Value.
 # This allows data to be read into a Value and written back to a JSON string
diff --git a/src/de.rs b/src/de.rs
index ffae118..de5507b 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -1,22 +1,20 @@
 //! Deserialize JSON data to a Rust data structure.
 
-use std::io;
-use std::marker::PhantomData;
-use std::result;
-use std::str::FromStr;
-use std::{i32, u64};
-
+use crate::error::{Error, ErrorCode, Result};
+use crate::lib::str::FromStr;
+use crate::lib::*;
+use crate::number::Number;
+use crate::read::{self, Reference};
 use serde::de::{self, Expected, Unexpected};
+use serde::{forward_to_deserialize_any, serde_if_integer128};
 
-use super::error::{Error, ErrorCode, Result};
-
-use read::{self, Reference};
-
-pub use read::{IoRead, Read, SliceRead, StrRead};
-
-use number::Number;
 #[cfg(feature = "arbitrary_precision")]
-use number::NumberDeserializer;
+use crate::number::NumberDeserializer;
+
+pub use crate::read::{Read, SliceRead, StrRead};
+
+#[cfg(feature = "std")]
+pub use crate::read::IoRead;
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -63,9 +61,10 @@
     }
 }
 
+#[cfg(feature = "std")]
 impl<R> Deserializer<read::IoRead<R>>
 where
-    R: io::Read,
+    R: crate::io::Read,
 {
     /// Creates a JSON deserializer from an `io::Read`.
     ///
@@ -97,9 +96,7 @@
     };
 }
 
-// Not public API. Should be pub(crate).
-#[doc(hidden)]
-pub enum ParserNumber {
+pub(crate) enum ParserNumber {
     F64(f64),
     U64(u64),
     I64(i64),
@@ -121,7 +118,7 @@
         }
     }
 
-    fn invalid_type(self, exp: &Expected) -> Error {
+    fn invalid_type(self, exp: &dyn Expected) -> Error {
         match self {
             ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp),
             ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp),
@@ -137,7 +134,7 @@
     /// This allows the `Deserializer` to validate that the input stream is at the end or that it
     /// only has trailing whitespace.
     pub fn end(&mut self) -> Result<()> {
-        match try!(self.parse_whitespace()) {
+        match tri!(self.parse_whitespace()) {
             Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
             None => Ok(()),
         }
@@ -175,7 +172,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde::Deserialize;
     /// use serde_jsonrc::Value;
     ///
@@ -212,7 +209,7 @@
     }
 
     fn peek_or_null(&mut self) -> Result<u8> {
-        Ok(try!(self.peek()).unwrap_or(b'\x00'))
+        Ok(tri!(self.peek()).unwrap_or(b'\x00'))
     }
 
     fn eat_char(&mut self) {
@@ -224,7 +221,7 @@
     }
 
     fn next_char_or_null(&mut self) -> Result<u8> {
-        Ok(try!(self.next_char()).unwrap_or(b'\x00'))
+        Ok(tri!(self.next_char()).unwrap_or(b'\x00'))
     }
 
     /// Error caused by a byte from next_char().
@@ -246,17 +243,17 @@
     fn parse_whitespace(&mut self) -> Result<Option<u8>> {
         // Consume comments as if they were whitespace.
         loop {
-            match try!(self.peek()) {
+            match tri!(self.peek()) {
                 Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => {
                     self.eat_char();
                 }
                 Some(b'/') => {
                     self.eat_char();
-                    match try!(self.peek()) {
+                    match tri!(self.peek()) {
                         Some(b'/') => {
                             // TODO: Read until newline.
                             loop {
-                                match try!(self.peek()) {
+                                match tri!(self.peek()) {
                                     Some(b'\n') => {
                                         self.eat_char();
                                         break;
@@ -271,10 +268,10 @@
                             }
                         }
                         Some(b'*') => loop {
-                            match try!(self.peek()) {
+                            match tri!(self.peek()) {
                                 Some(b'*') => {
                                     self.eat_char();
-                                    match try!(self.peek()) {
+                                    match tri!(self.peek()) {
                                         Some(b'/') => {
                                             self.eat_char();
                                             break;
@@ -310,7 +307,7 @@
     }
 
     #[cold]
-    fn peek_invalid_type(&mut self, exp: &Expected) -> Error {
+    fn peek_invalid_type(&mut self, exp: &dyn Expected) -> Error {
         let err = match self.peek_or_null().unwrap_or(b'\x00') {
             b'n' => {
                 self.eat_char();
@@ -340,7 +337,7 @@
                     Err(err) => return err,
                 }
             }
-            b'0'...b'9' => match self.parse_any_number(true) {
+            b'0'..=b'9' => match self.parse_any_number(true) {
                 Ok(n) => n.invalid_type(exp),
                 Err(err) => return err,
             },
@@ -364,7 +361,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -374,9 +371,9 @@
         let value = match peek {
             b'-' => {
                 self.eat_char();
-                try!(self.parse_integer(false)).visit(visitor)
+                tri!(self.parse_integer(false)).visit(visitor)
             }
-            b'0'...b'9' => try!(self.parse_integer(true)).visit(visitor),
+            b'0'..=b'9' => tri!(self.parse_integer(true)).visit(visitor),
             _ => Err(self.peek_invalid_type(&visitor)),
         };
 
@@ -388,20 +385,20 @@
 
     serde_if_integer128! {
         fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
-            match try!(self.next_char_or_null()) {
+            match tri!(self.next_char_or_null()) {
                 b'0' => {
                     buf.push('0');
                     // There can be only one leading '0'.
-                    match try!(self.peek_or_null()) {
-                        b'0'...b'9' => {
+                    match tri!(self.peek_or_null()) {
+                        b'0'..=b'9' => {
                             Err(self.peek_error(ErrorCode::InvalidNumber))
                         }
                         _ => Ok(()),
                     }
                 }
-                c @ b'1'...b'9' => {
+                c @ b'1'..=b'9' => {
                     buf.push(c as char);
-                    while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+                    while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
                         self.eat_char();
                         buf.push(c as char);
                     }
@@ -421,7 +418,7 @@
 
     fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
         for expected in ident {
-            match try!(self.next_char()) {
+            match tri!(self.next_char()) {
                 None => {
                     return Err(self.error(ErrorCode::EofWhileParsingValue));
                 }
@@ -437,7 +434,7 @@
     }
 
     fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> {
-        let next = match try!(self.next_char()) {
+        let next = match tri!(self.next_char()) {
             Some(b) => b,
             None => {
                 return Err(self.error(ErrorCode::EofWhileParsingValue));
@@ -447,17 +444,17 @@
         match next {
             b'0' => {
                 // There can be only one leading '0'.
-                match try!(self.peek_or_null()) {
-                    b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
+                match tri!(self.peek_or_null()) {
+                    b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
                     _ => self.parse_number(positive, 0),
                 }
             }
-            c @ b'1'...b'9' => {
+            c @ b'1'..=b'9' => {
                 let mut res = (c - b'0') as u64;
 
                 loop {
-                    match try!(self.peek_or_null()) {
-                        c @ b'0'...b'9' => {
+                    match tri!(self.peek_or_null()) {
+                        c @ b'0'..=b'9' => {
                             self.eat_char();
                             let digit = (c - b'0') as u64;
 
@@ -465,7 +462,7 @@
                             // number as a `u64` until we grow too large. At that point, switch to
                             // parsing the value as a `f64`.
                             if overflow!(res * 10 + digit, u64::max_value()) {
-                                return Ok(ParserNumber::F64(try!(
+                                return Ok(ParserNumber::F64(tri!(
                                     self.parse_long_integer(
                                     positive,
                                     res,
@@ -493,8 +490,8 @@
         mut exponent: i32,
     ) -> Result<f64> {
         loop {
-            match try!(self.peek_or_null()) {
-                b'0'...b'9' => {
+            match tri!(self.peek_or_null()) {
+                b'0'..=b'9' => {
                     self.eat_char();
                     // This could overflow... if your integer is gigabytes long.
                     // Ignore that possibility.
@@ -514,9 +511,9 @@
     }
 
     fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> {
-        Ok(match try!(self.peek_or_null()) {
-            b'.' => ParserNumber::F64(try!(self.parse_decimal(positive, significand, 0))),
-            b'e' | b'E' => ParserNumber::F64(try!(self.parse_exponent(positive, significand, 0))),
+        Ok(match tri!(self.peek_or_null()) {
+            b'.' => ParserNumber::F64(tri!(self.parse_decimal(positive, significand, 0))),
+            b'e' | b'E' => ParserNumber::F64(tri!(self.parse_exponent(positive, significand, 0))),
             _ => {
                 if positive {
                     ParserNumber::U64(significand)
@@ -543,7 +540,7 @@
         self.eat_char();
 
         let mut at_least_one_digit = false;
-        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
             let digit = (c - b'0') as u64;
             at_least_one_digit = true;
@@ -551,7 +548,7 @@
             if overflow!(significand * 10 + digit, u64::max_value()) {
                 // The next multiply/add would overflow, so just ignore all
                 // further digits.
-                while let b'0'...b'9' = try!(self.peek_or_null()) {
+                while let b'0'..=b'9' = tri!(self.peek_or_null()) {
                     self.eat_char();
                 }
                 break;
@@ -562,13 +559,13 @@
         }
 
         if !at_least_one_digit {
-            match try!(self.peek()) {
+            match tri!(self.peek()) {
                 Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
                 None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
             }
         }
 
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
             _ => self.f64_from_parts(positive, significand, exponent),
         }
@@ -582,7 +579,7 @@
     ) -> Result<f64> {
         self.eat_char();
 
-        let positive_exp = match try!(self.peek_or_null()) {
+        let positive_exp = match tri!(self.peek_or_null()) {
             b'+' => {
                 self.eat_char();
                 true
@@ -594,7 +591,7 @@
             _ => true,
         };
 
-        let next = match try!(self.next_char()) {
+        let next = match tri!(self.next_char()) {
             Some(b) => b,
             None => {
                 return Err(self.error(ErrorCode::EofWhileParsingValue));
@@ -603,13 +600,13 @@
 
         // Make sure a digit follows the exponent place.
         let mut exp = match next {
-            c @ b'0'...b'9' => (c - b'0') as i32,
+            c @ b'0'..=b'9' => (c - b'0') as i32,
             _ => {
                 return Err(self.error(ErrorCode::InvalidNumber));
             }
         };
 
-        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
             let digit = (c - b'0') as i32;
 
@@ -644,14 +641,14 @@
             return Err(self.error(ErrorCode::NumberOutOfRange));
         }
 
-        while let b'0'...b'9' = try!(self.peek_or_null()) {
+        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
         }
         Ok(if positive { 0.0 } else { -0.0 })
     }
 
     fn parse_any_signed_number(&mut self) -> Result<ParserNumber> {
-        let peek = match try!(self.peek()) {
+        let peek = match tri!(self.peek()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -663,11 +660,11 @@
                 self.eat_char();
                 self.parse_any_number(false)
             }
-            b'0'...b'9' => self.parse_any_number(true),
+            b'0'..=b'9' => self.parse_any_number(true),
             _ => Err(self.peek_error(ErrorCode::InvalidNumber)),
         };
 
-        let value = match try!(self.peek()) {
+        let value = match tri!(self.peek()) {
             Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)),
             None => value,
         };
@@ -700,7 +697,7 @@
 
     #[cfg(feature = "arbitrary_precision")]
     fn scan_or_eof(&mut self, buf: &mut String) -> Result<u8> {
-        match try!(self.next_char()) {
+        match tri!(self.next_char()) {
             Some(b) => {
                 buf.push(b as char);
                 Ok(b)
@@ -711,17 +708,17 @@
 
     #[cfg(feature = "arbitrary_precision")]
     fn scan_integer(&mut self, buf: &mut String) -> Result<()> {
-        match try!(self.scan_or_eof(buf)) {
+        match tri!(self.scan_or_eof(buf)) {
             b'0' => {
                 // There can be only one leading '0'.
-                match try!(self.peek_or_null()) {
-                    b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
+                match tri!(self.peek_or_null()) {
+                    b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
                     _ => self.scan_number(buf),
                 }
             }
-            b'1'...b'9' => loop {
-                match try!(self.peek_or_null()) {
-                    c @ b'0'...b'9' => {
+            b'1'..=b'9' => loop {
+                match tri!(self.peek_or_null()) {
+                    c @ b'0'..=b'9' => {
                         self.eat_char();
                         buf.push(c as char);
                     }
@@ -736,7 +733,7 @@
 
     #[cfg(feature = "arbitrary_precision")]
     fn scan_number(&mut self, buf: &mut String) -> Result<()> {
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'.' => self.scan_decimal(buf),
             b'e' | b'E' => self.scan_exponent(buf),
             _ => Ok(()),
@@ -749,20 +746,20 @@
         buf.push('.');
 
         let mut at_least_one_digit = false;
-        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
             buf.push(c as char);
             at_least_one_digit = true;
         }
 
         if !at_least_one_digit {
-            match try!(self.peek()) {
+            match tri!(self.peek()) {
                 Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
                 None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
             }
         }
 
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'e' | b'E' => self.scan_exponent(buf),
             _ => Ok(()),
         }
@@ -773,7 +770,7 @@
         self.eat_char();
         buf.push('e');
 
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'+' => {
                 self.eat_char();
             }
@@ -785,14 +782,14 @@
         }
 
         // Make sure a digit follows the exponent place.
-        match try!(self.scan_or_eof(buf)) {
-            b'0'...b'9' => {}
+        match tri!(self.scan_or_eof(buf)) {
+            b'0'..=b'9' => {}
             _ => {
                 return Err(self.error(ErrorCode::InvalidNumber));
             }
         }
 
-        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
             buf.push(c as char);
         }
@@ -836,7 +833,7 @@
     }
 
     fn parse_object_colon(&mut self) -> Result<()> {
-        match try!(self.parse_whitespace()) {
+        match tri!(self.parse_whitespace()) {
             Some(b':') => {
                 self.eat_char();
                 Ok(())
@@ -847,7 +844,7 @@
     }
 
     fn end_seq(&mut self) -> Result<()> {
-        match try!(self.parse_whitespace()) {
+        match tri!(self.parse_whitespace()) {
             Some(b']') => {
                 self.eat_char();
                 Ok(())
@@ -865,7 +862,7 @@
     }
 
     fn end_map(&mut self) -> Result<()> {
-        match try!(self.parse_whitespace()) {
+        match tri!(self.parse_whitespace()) {
             Some(b'}') => {
                 self.eat_char();
                 Ok(())
@@ -881,7 +878,7 @@
         let mut enclosing = None;
 
         loop {
-            let peek = match try!(self.parse_whitespace()) {
+            let peek = match tri!(self.parse_whitespace()) {
                 Some(b) => b,
                 None => {
                     return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -891,31 +888,31 @@
             let frame = match peek {
                 b'n' => {
                     self.eat_char();
-                    try!(self.parse_ident(b"ull"));
+                    tri!(self.parse_ident(b"ull"));
                     None
                 }
                 b't' => {
                     self.eat_char();
-                    try!(self.parse_ident(b"rue"));
+                    tri!(self.parse_ident(b"rue"));
                     None
                 }
                 b'f' => {
                     self.eat_char();
-                    try!(self.parse_ident(b"alse"));
+                    tri!(self.parse_ident(b"alse"));
                     None
                 }
                 b'-' => {
                     self.eat_char();
-                    try!(self.ignore_integer());
+                    tri!(self.ignore_integer());
                     None
                 }
-                b'0'...b'9' => {
-                    try!(self.ignore_integer());
+                b'0'..=b'9' => {
+                    tri!(self.ignore_integer());
                     None
                 }
                 b'"' => {
                     self.eat_char();
-                    try!(self.read.ignore_str());
+                    tri!(self.read.ignore_str());
                     None
                 }
                 frame @ b'[' | frame @ b'{' => {
@@ -938,7 +935,7 @@
             };
 
             loop {
-                match try!(self.parse_whitespace()) {
+                match tri!(self.parse_whitespace()) {
                     Some(b',') if accept_comma => {
                         self.eat_char();
                         break;
@@ -974,13 +971,13 @@
             }
 
             if frame == b'{' {
-                match try!(self.parse_whitespace()) {
+                match tri!(self.parse_whitespace()) {
                     Some(b'"') => self.eat_char(),
                     Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
                     None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
                 }
-                try!(self.read.ignore_str());
-                match try!(self.parse_whitespace()) {
+                tri!(self.read.ignore_str());
+                match tri!(self.parse_whitespace()) {
                     Some(b':') => self.eat_char(),
                     Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)),
                     None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
@@ -992,15 +989,15 @@
     }
 
     fn ignore_integer(&mut self) -> Result<()> {
-        match try!(self.next_char_or_null()) {
+        match tri!(self.next_char_or_null()) {
             b'0' => {
                 // There can be only one leading '0'.
-                if let b'0'...b'9' = try!(self.peek_or_null()) {
+                if let b'0'..=b'9' = tri!(self.peek_or_null()) {
                     return Err(self.peek_error(ErrorCode::InvalidNumber));
                 }
             }
-            b'1'...b'9' => {
-                while let b'0'...b'9' = try!(self.peek_or_null()) {
+            b'1'..=b'9' => {
+                while let b'0'..=b'9' = tri!(self.peek_or_null()) {
                     self.eat_char();
                 }
             }
@@ -1009,7 +1006,7 @@
             }
         }
 
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'.' => self.ignore_decimal(),
             b'e' | b'E' => self.ignore_exponent(),
             _ => Ok(()),
@@ -1020,7 +1017,7 @@
         self.eat_char();
 
         let mut at_least_one_digit = false;
-        while let b'0'...b'9' = try!(self.peek_or_null()) {
+        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
             at_least_one_digit = true;
         }
@@ -1029,7 +1026,7 @@
             return Err(self.peek_error(ErrorCode::InvalidNumber));
         }
 
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'e' | b'E' => self.ignore_exponent(),
             _ => Ok(()),
         }
@@ -1038,20 +1035,20 @@
     fn ignore_exponent(&mut self) -> Result<()> {
         self.eat_char();
 
-        match try!(self.peek_or_null()) {
+        match tri!(self.peek_or_null()) {
             b'+' | b'-' => self.eat_char(),
             _ => {}
         }
 
         // Make sure a digit follows the exponent place.
-        match try!(self.next_char_or_null()) {
-            b'0'...b'9' => {}
+        match tri!(self.next_char_or_null()) {
+            b'0'..=b'9' => {}
             _ => {
                 return Err(self.error(ErrorCode::InvalidNumber));
             }
         }
 
-        while let b'0'...b'9' = try!(self.peek_or_null()) {
+        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
             self.eat_char();
         }
 
@@ -1166,7 +1163,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1176,28 +1173,28 @@
         let value = match peek {
             b'n' => {
                 self.eat_char();
-                try!(self.parse_ident(b"ull"));
+                tri!(self.parse_ident(b"ull"));
                 visitor.visit_unit()
             }
             b't' => {
                 self.eat_char();
-                try!(self.parse_ident(b"rue"));
+                tri!(self.parse_ident(b"rue"));
                 visitor.visit_bool(true)
             }
             b'f' => {
                 self.eat_char();
-                try!(self.parse_ident(b"alse"));
+                tri!(self.parse_ident(b"alse"));
                 visitor.visit_bool(false)
             }
             b'-' => {
                 self.eat_char();
-                try!(self.parse_any_number(false)).visit(visitor)
+                tri!(self.parse_any_number(false)).visit(visitor)
             }
-            b'0'...b'9' => try!(self.parse_any_number(true)).visit(visitor),
+            b'0'..=b'9' => tri!(self.parse_any_number(true)).visit(visitor),
             b'"' => {
                 self.eat_char();
                 self.scratch.clear();
-                match try!(self.read.parse_str(&mut self.scratch)) {
+                match tri!(self.read.parse_str(&mut self.scratch)) {
                     Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
                     Reference::Copied(s) => visitor.visit_str(s),
                 }
@@ -1242,7 +1239,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1252,12 +1249,12 @@
         let value = match peek {
             b't' => {
                 self.eat_char();
-                try!(self.parse_ident(b"rue"));
+                tri!(self.parse_ident(b"rue"));
                 visitor.visit_bool(true)
             }
             b'f' => {
                 self.eat_char();
-                try!(self.parse_ident(b"alse"));
+                tri!(self.parse_ident(b"alse"));
                 visitor.visit_bool(false)
             }
             _ => Err(self.peek_invalid_type(&visitor)),
@@ -1287,7 +1284,7 @@
         {
             let mut buf = String::new();
 
-            match try!(self.parse_whitespace()) {
+            match tri!(self.parse_whitespace()) {
                 Some(b'-') => {
                     self.eat_char();
                     buf.push('-');
@@ -1298,7 +1295,7 @@
                 }
             };
 
-            try!(self.scan_integer128(&mut buf));
+            tri!(self.scan_integer128(&mut buf));
 
             let value = match buf.parse() {
                 Ok(int) => visitor.visit_i128(int),
@@ -1317,7 +1314,7 @@
         where
             V: de::Visitor<'de>,
         {
-            match try!(self.parse_whitespace()) {
+            match tri!(self.parse_whitespace()) {
                 Some(b'-') => {
                     return Err(self.peek_error(ErrorCode::NumberOutOfRange));
                 }
@@ -1328,7 +1325,7 @@
             }
 
             let mut buf = String::new();
-            try!(self.scan_integer128(&mut buf));
+            tri!(self.scan_integer128(&mut buf));
 
             let value = match buf.parse() {
                 Ok(int) => visitor.visit_u128(int),
@@ -1355,7 +1352,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1366,7 +1363,7 @@
             b'"' => {
                 self.eat_char();
                 self.scratch.clear();
-                match try!(self.read.parse_str(&mut self.scratch)) {
+                match tri!(self.read.parse_str(&mut self.scratch)) {
                     Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
                     Reference::Copied(s) => visitor.visit_str(s),
                 }
@@ -1422,7 +1419,7 @@
     ///
     /// You can use this to parse JSON strings containing invalid UTF-8 bytes.
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_bytes::ByteBuf;
     ///
     /// fn look_at_bytes() -> Result<(), serde_jsonrc::Error> {
@@ -1443,7 +1440,7 @@
     /// to be valid, and `\u` escape sequences are required to represent valid
     /// Unicode code points.
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_bytes::ByteBuf;
     ///
     /// fn look_at_bytes() {
@@ -1462,7 +1459,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1473,7 +1470,7 @@
             b'"' => {
                 self.eat_char();
                 self.scratch.clear();
-                match try!(self.read.parse_str_raw(&mut self.scratch)) {
+                match tri!(self.read.parse_str_raw(&mut self.scratch)) {
                     Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
                     Reference::Copied(b) => visitor.visit_bytes(b),
                 }
@@ -1502,10 +1499,10 @@
     where
         V: de::Visitor<'de>,
     {
-        match try!(self.parse_whitespace()) {
+        match tri!(self.parse_whitespace()) {
             Some(b'n') => {
                 self.eat_char();
-                try!(self.parse_ident(b"ull"));
+                tri!(self.parse_ident(b"ull"));
                 visitor.visit_none()
             }
             _ => visitor.visit_some(self),
@@ -1516,7 +1513,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1526,7 +1523,7 @@
         let value = match peek {
             b'n' => {
                 self.eat_char();
-                try!(self.parse_ident(b"ull"));
+                tri!(self.parse_ident(b"ull"));
                 visitor.visit_unit()
             }
             _ => Err(self.peek_invalid_type(&visitor)),
@@ -1553,7 +1550,7 @@
     {
         #[cfg(feature = "raw_value")]
         {
-            if name == ::raw::TOKEN {
+            if name == crate::raw::TOKEN {
                 return self.deserialize_raw_value(visitor);
             }
         }
@@ -1566,7 +1563,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1617,7 +1614,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1654,7 +1651,7 @@
     where
         V: de::Visitor<'de>,
     {
-        let peek = match try!(self.parse_whitespace()) {
+        let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
             None => {
                 return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
@@ -1705,14 +1702,14 @@
     where
         V: de::Visitor<'de>,
     {
-        match try!(self.parse_whitespace()) {
+        match tri!(self.parse_whitespace()) {
             Some(b'{') => {
                 check_recursion! {
                     self.eat_char();
-                    let value = try!(visitor.visit_enum(VariantAccess::new(self)));
+                    let value = tri!(visitor.visit_enum(VariantAccess::new(self)));
                 }
 
-                match try!(self.parse_whitespace()) {
+                match tri!(self.parse_whitespace()) {
                     Some(b'}') => {
                         self.eat_char();
                         Ok(value)
@@ -1738,7 +1735,7 @@
     where
         V: de::Visitor<'de>,
     {
-        try!(self.ignore_value());
+        tri!(self.ignore_value());
         visitor.visit_unit()
     }
 }
@@ -1760,16 +1757,16 @@
     where
         T: de::DeserializeSeed<'de>,
     {
-        match try!(self.de.parse_whitespace()) {
+        match tri!(self.de.parse_whitespace()) {
             Some(b) => {
                 // List most common branch first.
                 if b != b']' {
-                    let result = Ok(Some(try!(seed.deserialize(&mut *self.de))));
+                    let result = Ok(Some(tri!(seed.deserialize(&mut *self.de))));
                     if !result.is_ok() {
                         return result;
                     }
 
-                    match try!(self.de.parse_whitespace()) {
+                    match tri!(self.de.parse_whitespace()) {
                         Some(b',') => self.de.eat_char(),
                         Some(b']') => {
                             // Ignore.
@@ -1808,7 +1805,7 @@
     where
         K: de::DeserializeSeed<'de>,
     {
-        match try!(self.de.parse_whitespace()) {
+        match tri!(self.de.parse_whitespace()) {
             Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
             Some(b'}') => {
                 return Ok(None);
@@ -1822,10 +1819,10 @@
     where
         V: de::DeserializeSeed<'de>,
     {
-        try!(self.de.parse_object_colon());
+        tri!(self.de.parse_object_colon());
         let result = seed.deserialize(&mut *self.de);
         if result.is_ok() {
-            match try!(self.de.parse_whitespace()) {
+            match tri!(self.de.parse_whitespace()) {
                 Some(b',') => self.de.eat_char(),
                 Some(b'}') => {
                     // Ignore.
@@ -1860,8 +1857,8 @@
     where
         V: de::DeserializeSeed<'de>,
     {
-        let val = try!(seed.deserialize(&mut *self.de));
-        try!(self.de.parse_object_colon());
+        let val = tri!(seed.deserialize(&mut *self.de));
+        tri!(self.de.parse_object_colon());
         Ok((val, self))
     }
 }
@@ -1913,7 +1910,7 @@
     where
         V: de::DeserializeSeed<'de>,
     {
-        let variant = try!(seed.deserialize(&mut *self.de));
+        let variant = tri!(seed.deserialize(&mut *self.de));
         Ok((variant, self))
     }
 }
@@ -1970,7 +1967,7 @@
         {
             self.de.eat_char();
             self.de.scratch.clear();
-            let string = try!(self.de.read.parse_str(&mut self.de.scratch));
+            let string = tri!(self.de.read.parse_str(&mut self.de.scratch));
             match (string.parse(), string) {
                 (Ok(integer), _) => visitor.$visit(integer),
                 (Err(_), Reference::Borrowed(s)) => visitor.visit_borrowed_str(s),
@@ -1993,7 +1990,7 @@
     {
         self.de.eat_char();
         self.de.scratch.clear();
-        match try!(self.de.read.parse_str(&mut self.de.scratch)) {
+        match tri!(self.de.read.parse_str(&mut self.de.scratch)) {
             Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
             Reference::Copied(s) => visitor.visit_str(s),
         }
@@ -2075,7 +2072,7 @@
 /// The data can consist of any JSON value. Values need to be a self-delineating value e.g.
 /// arrays, objects, or strings, or be followed by whitespace or a self-delineating value.
 ///
-/// ```edition2018
+/// ```
 /// use serde_jsonrc::{Deserializer, Value};
 ///
 /// fn main() {
@@ -2123,7 +2120,7 @@
     /// If a stream deserializer returns an EOF error, new data can be joined to
     /// `old_data[stream.byte_offset()..]` to try again.
     ///
-    /// ```edition2018
+    /// ```
     /// let data = b"[0] [1] [";
     ///
     /// let de = serde_jsonrc::Deserializer::from_slice(data);
@@ -2154,7 +2151,7 @@
     }
 
     fn peek_end_of_value(&mut self) -> Result<()> {
-        match try!(self.de.peek()) {
+        match tri!(self.de.peek()) {
             Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') | Some(b'"') | Some(b'[')
             | Some(b']') | Some(b'{') | Some(b'}') | Some(b',') | Some(b':') | None => Ok(()),
             Some(_) => {
@@ -2221,10 +2218,10 @@
     T: de::Deserialize<'de>,
 {
     let mut de = Deserializer::new(read);
-    let value = try!(de::Deserialize::deserialize(&mut de));
+    let value = tri!(de::Deserialize::deserialize(&mut de));
 
     // Make sure the whole stream has been consumed.
-    try!(de.end());
+    tri!(de.end());
     Ok(value)
 }
 
@@ -2256,7 +2253,7 @@
 ///
 /// Reading the contents of a file.
 ///
-/// ```edition2018
+/// ```
 /// use serde::Deserialize;
 ///
 /// use std::error::Error;
@@ -2292,7 +2289,7 @@
 ///
 /// Reading from a persistent socket connection.
 ///
-/// ```edition2018
+/// ```
 /// use serde::Deserialize;
 ///
 /// use std::error::Error;
@@ -2331,9 +2328,10 @@
 /// is wrong with the data, for example required struct fields are missing from
 /// the JSON map or some number is too big to fit in the expected primitive
 /// type.
+#[cfg(feature = "std")]
 pub fn from_reader<R, T>(rdr: R) -> Result<T>
 where
-    R: io::Read,
+    R: crate::io::Read,
     T: de::DeserializeOwned,
 {
     from_trait(read::IoRead::new(rdr))
@@ -2343,7 +2341,7 @@
 ///
 /// # Example
 ///
-/// ```edition2018
+/// ```
 /// use serde::Deserialize;
 ///
 /// #[derive(Deserialize, Debug)]
@@ -2385,7 +2383,7 @@
 ///
 /// # Example
 ///
-/// ```edition2018
+/// ```
 /// use serde::Deserialize;
 ///
 /// #[derive(Deserialize, Debug)]
diff --git a/src/error.rs b/src/error.rs
index 4cebca5..6cad288 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,13 +1,9 @@
 //! When serializing or deserializing JSON goes wrong.
 
-use std::error;
-use std::fmt::{self, Debug, Display};
-use std::io;
-use std::result;
-use std::str::FromStr;
-
-use serde::de;
-use serde::ser;
+use crate::io;
+use crate::lib::str::FromStr;
+use crate::lib::*;
+use serde::{de, ser};
 
 /// This type represents all possible errors that can occur when serializing or
 /// deserializing JSON data.
@@ -60,10 +56,8 @@
             | ErrorCode::ExpectedCommentSlashOrStar
             | ErrorCode::ExpectedListCommaOrEnd
             | ErrorCode::ExpectedObjectCommaOrEnd
-            | ErrorCode::ExpectedObjectOrArray
             | ErrorCode::ExpectedSomeIdent
             | ErrorCode::ExpectedSomeValue
-            | ErrorCode::ExpectedSomeString
             | ErrorCode::InvalidEscape
             | ErrorCode::InvalidNumber
             | ErrorCode::NumberOutOfRange
@@ -132,14 +126,15 @@
     Eof,
 }
 
-#[cfg_attr(feature = "cargo-clippy", allow(fallible_impl_from))]
+#[cfg(feature = "std")]
+#[allow(clippy::fallible_impl_from)]
 impl From<Error> for io::Error {
     /// Convert a `serde_jsonrc::Error` into an `io::Error`.
     ///
     /// JSON syntax and data errors are turned into `InvalidData` IO errors.
     /// EOF errors are turned into `UnexpectedEof` IO errors.
     ///
-    /// ```edition2018
+    /// ```
     /// use std::io;
     ///
     /// enum MyError {
@@ -180,9 +175,7 @@
     column: usize,
 }
 
-// Not public API. Should be pub(crate).
-#[doc(hidden)]
-pub enum ErrorCode {
+pub(crate) enum ErrorCode {
     /// Catchall for syntax error messages
     Message(Box<str>),
 
@@ -217,18 +210,12 @@
     /// Expected this character to be either a `','` or a `'}'`.
     ExpectedObjectCommaOrEnd,
 
-    /// Expected this character to be either a `'{'` or a `'['`.
-    ExpectedObjectOrArray,
-
     /// Expected to parse either a `true`, `false`, or a `null`.
     ExpectedSomeIdent,
 
     /// Expected this character to start a JSON value.
     ExpectedSomeValue,
 
-    /// Expected this character to start a JSON string.
-    ExpectedSomeString,
-
     /// Invalid hex escape code.
     InvalidEscape,
 
@@ -264,10 +251,8 @@
 }
 
 impl Error {
-    // Not public API. Should be pub(crate).
-    #[doc(hidden)]
     #[cold]
-    pub fn syntax(code: ErrorCode, line: usize, column: usize) -> Self {
+    pub(crate) fn syntax(code: ErrorCode, line: usize, column: usize) -> Self {
         Error {
             err: Box::new(ErrorImpl {
                 code: code,
@@ -292,10 +277,8 @@
         }
     }
 
-    // Not public API. Should be pub(crate).
-    #[doc(hidden)]
     #[cold]
-    pub fn fix_position<F>(self, f: F) -> Self
+    pub(crate) fn fix_position<F>(self, f: F) -> Self
     where
         F: FnOnce(ErrorCode) -> Error,
     {
@@ -323,10 +306,8 @@
             ErrorCode::ExpectedCommentSlashOrStar => f.write_str("expected `/` or `*` after `/`"),
             ErrorCode::ExpectedListCommaOrEnd => f.write_str("expected `,` or `]`"),
             ErrorCode::ExpectedObjectCommaOrEnd => f.write_str("expected `,` or `}`"),
-            ErrorCode::ExpectedObjectOrArray => f.write_str("expected `{` or `[`"),
             ErrorCode::ExpectedSomeIdent => f.write_str("expected ident"),
             ErrorCode::ExpectedSomeValue => f.write_str("expected value"),
-            ErrorCode::ExpectedSomeString => f.write_str("expected string"),
             ErrorCode::InvalidEscape => f.write_str("invalid escape"),
             ErrorCode::InvalidNumber => f.write_str("invalid number"),
             ErrorCode::NumberOutOfRange => f.write_str("number out of range"),
@@ -346,18 +327,9 @@
     }
 }
 
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match self.err.code {
-            ErrorCode::Io(ref err) => error::Error::description(err),
-            _ => {
-                // If you want a better message, use Display::fmt or to_string().
-                "JSON error"
-            }
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
+impl serde::de::StdError for Error {
+    #[cfg(feature = "std")]
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match self.err.code {
             ErrorCode::Io(ref err) => Some(err),
             _ => None,
@@ -406,7 +378,7 @@
     }
 
     #[cold]
-    fn invalid_type(unexp: de::Unexpected, exp: &de::Expected) -> Self {
+    fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
         if let de::Unexpected::Unit = unexp {
             Error::custom(format_args!("invalid type: null, expected {}", exp))
         } else {
diff --git a/src/features_check/error.rs b/src/features_check/error.rs
new file mode 100644
index 0000000..22e5823
--- /dev/null
+++ b/src/features_check/error.rs
@@ -0,0 +1 @@
+"serde_json requires that either `std` (default) or `alloc` feature is enabled"
diff --git a/src/features_check/mod.rs b/src/features_check/mod.rs
new file mode 100644
index 0000000..d12032c
--- /dev/null
+++ b/src/features_check/mod.rs
@@ -0,0 +1,13 @@
+//! Shows a user-friendly compiler error on incompatible selected features.
+
+#[allow(unused_macros)]
+macro_rules! hide_from_rustfmt {
+    ($mod:item) => {
+        $mod
+    };
+}
+
+#[cfg(not(any(feature = "std", feature = "alloc")))]
+hide_from_rustfmt! {
+    mod error;
+}
diff --git a/src/io/core.rs b/src/io/core.rs
new file mode 100644
index 0000000..97354eb
--- /dev/null
+++ b/src/io/core.rs
@@ -0,0 +1,77 @@
+//! Reimplements core logic and types from `std::io` in an `alloc`-friendly
+//! fashion.
+
+use crate::lib::*;
+
+pub enum ErrorKind {
+    Other,
+}
+
+// IO errors can never occur in no-std mode. All our no-std IO implementations
+// are infallible.
+pub struct Error;
+
+impl Display for Error {
+    fn fmt(&self, _formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        unreachable!()
+    }
+}
+
+impl Error {
+    pub(crate) fn new(_kind: ErrorKind, _error: &'static str) -> Error {
+        Error
+    }
+}
+
+pub type Result<T> = result::Result<T, Error>;
+
+pub trait Write {
+    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+
+    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
+        // All our Write impls in no_std mode always write the whole buffer in
+        // one call infallibly.
+        let result = self.write(buf);
+        debug_assert!(result.is_ok());
+        debug_assert_eq!(result.unwrap_or(0), buf.len());
+        Ok(())
+    }
+
+    fn flush(&mut self) -> Result<()>;
+}
+
+impl<W: Write> Write for &mut W {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        (*self).write(buf)
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
+        (*self).write_all(buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> Result<()> {
+        (*self).flush()
+    }
+}
+
+impl Write for Vec<u8> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        self.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
+        self.extend_from_slice(buf);
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> Result<()> {
+        Ok(())
+    }
+}
diff --git a/src/io/mod.rs b/src/io/mod.rs
new file mode 100644
index 0000000..9dee4a0
--- /dev/null
+++ b/src/io/mod.rs
@@ -0,0 +1,20 @@
+//! A tiny, `no_std`-friendly facade around `std::io`.
+//! Reexports types from `std` when available; otherwise reimplements and
+//! provides some of the core logic.
+//!
+//! The main reason that `std::io` hasn't found itself reexported as part of
+//! the `core` crate is the `std::io::{Read, Write}` traits' reliance on
+//! `std::io::Error`, which may contain internally a heap-allocated `Box<Error>`
+//! and/or now relying on OS-specific `std::backtrace::Backtrace`.
+
+pub use self::imp::{Error, ErrorKind, Result, Write};
+
+#[cfg(not(feature = "std"))]
+#[path = "core.rs"]
+mod imp;
+
+#[cfg(feature = "std")]
+use std::io as imp;
+
+#[cfg(feature = "std")]
+pub use std::io::{Bytes, Read};
diff --git a/src/iter.rs b/src/iter.rs
index 1a9a954..1219f08 100644
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -1,4 +1,4 @@
-use std::io;
+use crate::io;
 
 pub struct LineColIterator<I> {
     iter: I,
diff --git a/src/lib.rs b/src/lib.rs
index 069441a..f09da9b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -49,7 +49,7 @@
 //! Any valid JSON data can be manipulated in the following recursive enum
 //! representation. This data structure is [`serde_jsonrc::Value`][value].
 //!
-//! ```edition2018
+//! ```
 //! # use serde_jsonrc::{Number, Map};
 //! #
 //! # #[allow(dead_code)]
@@ -69,7 +69,7 @@
 //! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
 //! a TCP stream.
 //!
-//! ```edition2018
+//! ```
 //! use serde_jsonrc::{Result, Value};
 //!
 //! fn untyped_example() -> Result<()> {
@@ -127,7 +127,7 @@
 //! Serde provides a powerful way of mapping JSON data into Rust data structures
 //! largely automatically.
 //!
-//! ```edition2018
+//! ```
 //! use serde::{Deserialize, Serialize};
 //! use serde_jsonrc::Result;
 //!
@@ -189,7 +189,7 @@
 //! Serde jsonrc provides a [`json!` macro][macro] to build `serde_jsonrc::Value`
 //! objects with very natural JSON syntax.
 //!
-//! ```edition2018
+//! ```
 //! use serde_jsonrc::json;
 //!
 //! fn main() {
@@ -218,7 +218,7 @@
 //! will check at compile time that the value you are interpolating is able to
 //! be represented as JSON.
 //!
-//! ```edition2018
+//! ```
 //! # use serde_jsonrc::json;
 //! #
 //! # fn random_phone() -> u16 { 0 }
@@ -249,7 +249,7 @@
 //! [`serde_jsonrc::to_writer`][to_writer] which serializes to any `io::Write`
 //! such as a File or a TCP stream.
 //!
-//! ```edition2018
+//! ```
 //! use serde::{Deserialize, Serialize};
 //! use serde_jsonrc::Result;
 //!
@@ -287,8 +287,17 @@
 //!
 //! # No-std support
 //!
-//! This crate currently requires the Rust standard library. For JSON support in
-//! Serde without a standard library, please see the [`serde-json-core`] crate.
+//! As long as there is a memory allocator, it is possible to use serde_json
+//! without the rest of the Rust standard library. This is supported on Rust
+//! 1.36+. Disable the default "std" feature and enable the "alloc" feature:
+//!
+//! ```toml
+//! [dependencies]
+//! serde_jsonrc = { version = "1.0", default-features = false, features = ["alloc"] }
+//! ```
+//!
+//! For JSON support in Serde without a memory allocator, please see the
+//! [`serde-json-core`] crate.
 //!
 //! [value]: https://docs.serde.rs/serde_jsonrc/value/enum.Value.html
 //! [from_str]: https://docs.serde.rs/serde_jsonrc/de/fn.from_str.html
@@ -300,66 +309,122 @@
 //! [macro]: https://docs.serde.rs/serde_jsonrc/macro.json.html
 //! [`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_jsonrc_core/
 
-#![doc(html_root_url = "https://docs.rs/serde_jsonrc/0.1.1")]
-#![allow(unknown_lints, bare_trait_objects, ellipsis_inclusive_range_patterns)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
+#![doc(html_root_url = "https://docs.rs/serde_jsonrc/0.1.2")]
+#![deny(clippy::all, clippy::pedantic)]
 // Ignored clippy lints
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(deprecated_cfg_attr, doc_markdown, needless_doctest_main)
+#![allow(
+    clippy::deprecated_cfg_attr,
+    clippy::doc_markdown,
+    clippy::needless_doctest_main,
+    clippy::transmute_ptr_to_ptr
 )]
 // Ignored clippy_pedantic lints
-#![cfg_attr(feature = "cargo-clippy", allow(
+#![allow(
     // Deserializer::from_str, into_iter
-    should_implement_trait,
+    clippy::should_implement_trait,
     // integer and float ser/de requires these sorts of casts
-    cast_possible_wrap,
-    cast_precision_loss,
-    cast_sign_loss,
+    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
+    clippy::cast_sign_loss,
     // correctly used
-    integer_division,
+    clippy::integer_division,
     // things are often more readable this way
-    cast_lossless,
-    module_name_repetitions,
-    shadow_unrelated,
-    single_match_else,
-    too_many_lines,
-    use_self,
-    zero_prefixed_literal,
+    clippy::cast_lossless,
+    clippy::module_name_repetitions,
+    clippy::shadow_unrelated,
+    clippy::single_match_else,
+    clippy::too_many_lines,
+    clippy::use_self,
+    clippy::zero_prefixed_literal,
     // we support older compilers
-    checked_conversions,
-    redundant_field_names,
+    clippy::checked_conversions,
+    clippy::redundant_field_names,
     // noisy
-    must_use_candidate,
-))]
+    clippy::missing_errors_doc,
+    clippy::must_use_candidate,
+)]
 #![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
 
-#[macro_use]
-extern crate serde;
-#[cfg(feature = "preserve_order")]
-extern crate indexmap;
-extern crate itoa;
-extern crate ryu;
+////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+/// A facade around all the types we need from the `std`, `core`, and `alloc`
+/// crates. This avoids elaborate import wrangling having to happen in every
+/// module.
+mod lib {
+    mod core {
+        #[cfg(not(feature = "std"))]
+        pub use core::*;
+        #[cfg(feature = "std")]
+        pub use std::*;
+    }
+
+    pub use self::core::cell::{Cell, RefCell};
+    pub use self::core::clone::{self, Clone};
+    pub use self::core::convert::{self, From, Into};
+    pub use self::core::default::{self, Default};
+    pub use self::core::fmt::{self, Debug, Display};
+    pub use self::core::hash::{self, Hash};
+    pub use self::core::marker::{self, PhantomData};
+    pub use self::core::result::{self, Result};
+    pub use self::core::{borrow, char, cmp, iter, mem, num, ops, slice, str};
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::borrow::{Cow, ToOwned};
+    #[cfg(feature = "std")]
+    pub use std::borrow::{Cow, ToOwned};
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::string::{String, ToString};
+    #[cfg(feature = "std")]
+    pub use std::string::{String, ToString};
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::vec::{self, Vec};
+    #[cfg(feature = "std")]
+    pub use std::vec::{self, Vec};
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::boxed::Box;
+    #[cfg(feature = "std")]
+    pub use std::boxed::Box;
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::collections::{btree_map, BTreeMap};
+    #[cfg(feature = "std")]
+    pub use std::collections::{btree_map, BTreeMap};
+
+    #[cfg(feature = "std")]
+    pub use std::error;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "std")]
 #[doc(inline)]
-pub use self::de::{from_reader, from_slice, from_str, Deserializer, StreamDeserializer};
+pub use crate::de::from_reader;
 #[doc(inline)]
-pub use self::error::{Error, Result};
+pub use crate::de::{from_slice, from_str, Deserializer, StreamDeserializer};
 #[doc(inline)]
-pub use self::ser::{
-    to_string, to_string_pretty, to_vec, to_vec_pretty, to_writer, to_writer_pretty, Serializer,
-};
+pub use crate::error::{Error, Result};
 #[doc(inline)]
-pub use self::value::{from_value, to_value, Map, Number, Value};
+pub use crate::ser::{to_string, to_string_pretty, to_vec, to_vec_pretty};
+#[cfg(feature = "std")]
+#[doc(inline)]
+pub use crate::ser::{to_writer, to_writer_pretty, Serializer};
+#[doc(inline)]
+pub use crate::value::{from_value, to_value, Map, Number, Value};
 
 // We only use our own error type; no need for From conversions provided by the
 // standard library's try! macro. This reduces lines of LLVM IR by 4%.
-macro_rules! try {
+macro_rules! tri {
     ($e:expr) => {
         match $e {
-            ::std::result::Result::Ok(val) => val,
-            ::std::result::Result::Err(err) => return ::std::result::Result::Err(err),
+            crate::lib::Result::Ok(val) => val,
+            crate::lib::Result::Err(err) => return crate::lib::Result::Err(err),
         }
     };
 }
@@ -370,9 +435,16 @@
 pub mod de;
 pub mod error;
 pub mod map;
+#[cfg(feature = "std")]
 pub mod ser;
+#[cfg(not(feature = "std"))]
+mod ser;
 pub mod value;
 
+mod features_check;
+
+mod io;
+#[cfg(feature = "std")]
 mod iter;
 mod number;
 mod read;
diff --git a/src/macros.rs b/src/macros.rs
index f6d8ccb..c460bc0 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,6 +1,6 @@
 /// Construct a `serde_jsonrc::Value` from a JSON literal.
 ///
-/// ```edition2018
+/// ```
 /// # use serde_jsonrc::json;
 /// #
 /// let value = json!({
@@ -22,7 +22,7 @@
 /// interpolated type decides to fail, or if the interpolated type contains a
 /// map with non-string keys, the `json!` macro will panic.
 ///
-/// ```edition2018
+/// ```
 /// # use serde_jsonrc::json;
 /// #
 /// let code = 200;
@@ -39,7 +39,7 @@
 ///
 /// Trailing commas are allowed inside both arrays and objects.
 ///
-/// ```edition2018
+/// ```
 /// # use serde_jsonrc::json;
 /// #
 /// let value = json!([
diff --git a/src/map.rs b/src/map.rs
index 5e13df9..b93b795 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -6,16 +6,11 @@
 //! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
 //! [`IndexMap`]: https://docs.rs/indexmap/*/indexmap/map/struct.IndexMap.html
 
+use crate::lib::borrow::Borrow;
+use crate::lib::iter::FromIterator;
+use crate::lib::*;
+use crate::value::Value;
 use serde::{de, ser};
-use std::borrow::Borrow;
-use std::fmt::{self, Debug};
-use std::hash::Hash;
-use std::iter::FromIterator;
-use std::ops;
-use value::Value;
-
-#[cfg(not(feature = "preserve_order"))]
-use std::collections::{btree_map, BTreeMap};
 
 #[cfg(feature = "preserve_order")]
 use indexmap::{self, IndexMap};
@@ -132,16 +127,27 @@
         return self.map.remove(key);
     }
 
+    /// Moves all elements from other into Self, leaving other empty.
+    #[inline]
+    pub fn append(&mut self, other: &mut Self) {
+        #[cfg(feature = "preserve_order")]
+        for (k, v) in std::mem::replace(&mut other.map, MapImpl::default()).into_iter() {
+            self.map.insert(k, v);
+        }
+        #[cfg(not(feature = "preserve_order"))]
+        self.map.append(&mut other.map);
+    }
+
     /// Gets the given key's corresponding entry in the map for in-place
     /// manipulation.
     pub fn entry<S>(&mut self, key: S) -> Entry
     where
         S: Into<String>,
     {
+        #[cfg(not(feature = "preserve_order"))]
+        use crate::lib::btree_map::Entry as EntryImpl;
         #[cfg(feature = "preserve_order")]
         use indexmap::map::Entry as EntryImpl;
-        #[cfg(not(feature = "preserve_order"))]
-        use std::collections::btree_map::Entry as EntryImpl;
 
         match self.map.entry(key.into()) {
             EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant: vacant }),
@@ -239,7 +245,7 @@
 /// Access an element of this map. Panics if the given key is not present in the
 /// map.
 ///
-/// ```edition2018
+/// ```
 /// # use serde_jsonrc::Value;
 /// #
 /// # let val = &Value::String("".to_owned());
@@ -267,7 +273,7 @@
 /// Mutably access an element of this map. Panics if the given key is not
 /// present in the map.
 ///
-/// ```edition2018
+/// ```
 /// # use serde_jsonrc::json;
 /// #
 /// # let mut map = serde_jsonrc::Map::new();
@@ -299,10 +305,10 @@
         S: ser::Serializer,
     {
         use serde::ser::SerializeMap;
-        let mut map = try!(serializer.serialize_map(Some(self.len())));
+        let mut map = tri!(serializer.serialize_map(Some(self.len())));
         for (k, v) in self {
-            try!(map.serialize_key(k));
-            try!(map.serialize_value(v));
+            tri!(map.serialize_key(k));
+            tri!(map.serialize_value(v));
         }
         map.end()
     }
@@ -338,7 +344,7 @@
             {
                 let mut values = Map::new();
 
-                while let Some((key, value)) = try!(visitor.next_entry()) {
+                while let Some((key, value)) = tri!(visitor.next_entry()) {
                     values.insert(key, value);
                 }
 
@@ -443,7 +449,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// let mut map = serde_jsonrc::Map::new();
     /// assert_eq!(map.entry("serde").key(), &"serde");
     /// ```
@@ -459,7 +465,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut map = serde_jsonrc::Map::new();
@@ -480,7 +486,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut map = serde_jsonrc::Map::new();
@@ -505,7 +511,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::map::Entry;
     ///
     /// let mut map = serde_jsonrc::Map::new();
@@ -527,7 +533,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
@@ -552,7 +558,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
@@ -576,7 +582,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
@@ -600,7 +606,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
@@ -626,7 +632,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
@@ -653,7 +659,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
@@ -678,7 +684,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// use serde_jsonrc::map::Entry;
diff --git a/src/number.rs b/src/number.rs
index 7ed3066..638c1d4 100644
--- a/src/number.rs
+++ b/src/number.rs
@@ -1,24 +1,19 @@
-use error::Error;
+use crate::de::ParserNumber;
+use crate::error::Error;
+use crate::lib::*;
 use serde::de::{self, Unexpected, Visitor};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::fmt::{self, Debug, Display};
+use serde::{
+    forward_to_deserialize_any, serde_if_integer128, Deserialize, Deserializer, Serialize,
+    Serializer,
+};
 
 #[cfg(feature = "arbitrary_precision")]
-use itoa;
-#[cfg(feature = "arbitrary_precision")]
-use ryu;
+use crate::error::ErrorCode;
 #[cfg(feature = "arbitrary_precision")]
 use serde::de::{IntoDeserializer, MapAccess};
 
-use de::ParserNumber;
-
 #[cfg(feature = "arbitrary_precision")]
-use error::ErrorCode;
-
-#[cfg(feature = "arbitrary_precision")]
-/// Not public API. Should be pub(crate).
-#[doc(hidden)]
-pub const TOKEN: &'static str = "$serde_jsonrc::private::Number";
+pub(crate) const TOKEN: &str = "$serde_jsonrc::private::Number";
 
 /// Represents a JSON number, whether integer or floating point.
 #[derive(Clone, PartialEq)]
@@ -46,7 +41,7 @@
     /// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to
     /// return the integer value.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let big = i64::max_value() as u64 + 10;
@@ -77,7 +72,7 @@
     /// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to
     /// return the integer value.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
@@ -109,7 +104,7 @@
     /// Currently this function returns true if and only if both `is_i64` and
     /// `is_u64` return false but this is not a guarantee in the future.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
@@ -141,7 +136,7 @@
     /// If the `Number` is an integer, represent it as i64 if possible. Returns
     /// None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let big = i64::max_value() as u64 + 10;
@@ -172,7 +167,7 @@
     /// If the `Number` is an integer, represent it as u64 if possible. Returns
     /// None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
@@ -194,7 +189,7 @@
 
     /// Represents the number as f64 if possible. Returns None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
@@ -218,7 +213,7 @@
     /// Converts a finite `f64` to a `Number`. Infinite or NaN values are not JSON
     /// numbers.
     ///
-    /// ```edition2018
+    /// ```
     /// # use std::f64;
     /// #
     /// # use serde_jsonrc::Number;
@@ -434,7 +429,7 @@
             where
                 E: de::Error,
             {
-                let n = try!(s.parse().map_err(de::Error::custom));
+                let n = tri!(s.parse().map_err(de::Error::custom));
                 Ok(NumberFromString { value: n })
             }
         }
@@ -570,9 +565,7 @@
 }
 
 #[cfg(feature = "arbitrary_precision")]
-// Not public API. Should be pub(crate).
-#[doc(hidden)]
-pub struct NumberDeserializer {
+pub(crate) struct NumberDeserializer {
     pub number: Option<String>,
 }
 
@@ -731,10 +724,8 @@
 
 impl Number {
     #[cfg(not(feature = "arbitrary_precision"))]
-    // Not public API. Should be pub(crate).
-    #[doc(hidden)]
     #[cold]
-    pub fn unexpected(&self) -> Unexpected {
+    pub(crate) fn unexpected(&self) -> Unexpected {
         match self.n {
             N::PosInt(u) => Unexpected::Unsigned(u),
             N::NegInt(i) => Unexpected::Signed(i),
@@ -743,10 +734,8 @@
     }
 
     #[cfg(feature = "arbitrary_precision")]
-    // Not public API. Should be pub(crate).
-    #[doc(hidden)]
     #[cold]
-    pub fn unexpected(&self) -> Unexpected {
+    pub(crate) fn unexpected(&self) -> Unexpected {
         Unexpected::Other("number")
     }
 }
diff --git a/src/raw.rs b/src/raw.rs
index 0aea3f6..2d7703a 100644
--- a/src/raw.rs
+++ b/src/raw.rs
@@ -1,15 +1,13 @@
-use std::fmt::{self, Debug, Display};
-use std::mem;
-
+use crate::error::Error;
+use crate::lib::*;
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::{
     self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected,
     Visitor,
 };
+use serde::forward_to_deserialize_any;
 use serde::ser::{Serialize, SerializeStruct, Serializer};
 
-use error::Error;
-
 /// Reference to a range of bytes encompassing a single valid JSON value in the
 /// input data.
 ///
@@ -32,7 +30,7 @@
 ///
 /// # Example
 ///
-/// ```edition2018
+/// ```
 /// use serde::{Deserialize, Serialize};
 /// use serde_jsonrc::{Result, value::RawValue};
 ///
@@ -78,7 +76,7 @@
 ///
 /// The typical usage of `RawValue` will be in the borrowed form:
 ///
-/// ```edition2018
+/// ```
 /// # use serde::Deserialize;
 /// # use serde_jsonrc::value::RawValue;
 /// #
@@ -101,7 +99,7 @@
 /// [`serde_jsonrc::from_slice`]: ../fn.from_slice.html
 /// [`serde_jsonrc::from_reader`]: ../fn.from_reader.html
 ///
-/// ```edition2018
+/// ```
 /// # use serde::Deserialize;
 /// # use serde_jsonrc::value::RawValue;
 /// #
@@ -171,7 +169,7 @@
     /// - the input has capacity equal to its length.
     pub fn from_string(json: String) -> Result<Box<Self>, Error> {
         {
-            let borrowed = ::from_str::<&Self>(&json)?;
+            let borrowed = crate::from_str::<&Self>(&json)?;
             if borrowed.json.len() < json.len() {
                 return Ok(borrowed.to_owned());
             }
@@ -183,7 +181,7 @@
     ///
     /// # Example
     ///
-    /// ```edition2018
+    /// ```
     /// use serde::Deserialize;
     /// use serde_jsonrc::{Result, value::RawValue};
     ///
@@ -217,7 +215,7 @@
     }
 }
 
-pub const TOKEN: &'static str = "$serde_jsonrc::private::RawValue";
+pub const TOKEN: &str = "$serde_jsonrc::private::RawValue";
 
 impl Serialize for RawValue {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
diff --git a/src/read.rs b/src/read.rs
index 00538d9..3847f72 100644
--- a/src/read.rs
+++ b/src/read.rs
@@ -1,16 +1,19 @@
-use std::ops::Deref;
-use std::{char, cmp, io, str};
+use crate::error::{Error, ErrorCode, Result};
+use crate::lib::ops::Deref;
+use crate::lib::*;
 
+#[cfg(feature = "std")]
+use crate::io;
+#[cfg(feature = "std")]
+use crate::iter::LineColIterator;
+
+#[cfg(feature = "raw_value")]
+use crate::raw::BorrowedRawDeserializer;
+#[cfg(all(feature = "raw_value", feature = "std"))]
+use crate::raw::OwnedRawDeserializer;
 #[cfg(feature = "raw_value")]
 use serde::de::Visitor;
 
-use iter::LineColIterator;
-
-use error::{Error, ErrorCode, Result};
-
-#[cfg(feature = "raw_value")]
-use raw::{BorrowedRawDeserializer, OwnedRawDeserializer};
-
 /// Trait used by the deserializer for iterating over input. This is manually
 /// "specialized" for iterating over &[u8]. Once feature(specialization) is
 /// stable we can use actual specialization.
@@ -118,6 +121,7 @@
 }
 
 /// JSON input source that reads from a std::io input stream.
+#[cfg(feature = "std")]
 pub struct IoRead<R>
 where
     R: io::Read,
@@ -157,6 +161,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
+#[cfg(feature = "std")]
 impl<R> IoRead<R>
 where
     R: io::Read,
@@ -181,8 +186,10 @@
     }
 }
 
+#[cfg(feature = "std")]
 impl<R> private::Sealed for IoRead<R> where R: io::Read {}
 
+#[cfg(feature = "std")]
 impl<R> IoRead<R>
 where
     R: io::Read,
@@ -198,7 +205,7 @@
         F: FnOnce(&'s Self, &'s [u8]) -> Result<T>,
     {
         loop {
-            let ch = try!(next_or_eof(self));
+            let ch = tri!(next_or_eof(self));
             if !ESCAPE[ch as usize] {
                 scratch.push(ch);
                 continue;
@@ -208,7 +215,7 @@
                     return result(self, scratch);
                 }
                 b'\\' => {
-                    try!(parse_escape(self, scratch));
+                    tri!(parse_escape(self, scratch));
                 }
                 _ => {
                     if validate {
@@ -221,6 +228,7 @@
     }
 }
 
+#[cfg(feature = "std")]
 impl<'de, R> Read<'de> for IoRead<R>
 where
     R: io::Read,
@@ -318,7 +326,7 @@
 
     fn ignore_str(&mut self) -> Result<()> {
         loop {
-            let ch = try!(next_or_eof(self));
+            let ch = tri!(next_or_eof(self));
             if !ESCAPE[ch as usize] {
                 continue;
             }
@@ -327,7 +335,7 @@
                     return Ok(());
                 }
                 b'\\' => {
-                    try!(ignore_escape(self));
+                    tri!(ignore_escape(self));
                 }
                 _ => {
                     return error(self, ErrorCode::ControlCharacterWhileParsingString);
@@ -339,7 +347,7 @@
     fn decode_hex_escape(&mut self) -> Result<u16> {
         let mut n = 0;
         for _ in 0..4 {
-            match decode_hex_val(try!(next_or_eof(self))) {
+            match decode_hex_val(tri!(next_or_eof(self))) {
                 None => return error(self, ErrorCode::InvalidEscape),
                 Some(val) => {
                     n = (n << 4) + val;
@@ -445,7 +453,7 @@
                 b'\\' => {
                     scratch.extend_from_slice(&self.slice[start..self.index]);
                     self.index += 1;
-                    try!(parse_escape(self, scratch));
+                    tri!(parse_escape(self, scratch));
                     start = self.index;
                 }
                 _ => {
@@ -531,7 +539,7 @@
                 }
                 b'\\' => {
                     self.index += 1;
-                    try!(ignore_escape(self));
+                    tri!(ignore_escape(self));
                 }
                 _ => {
                     return error(self, ErrorCode::ControlCharacterWhileParsingString);
@@ -674,7 +682,7 @@
 // Lookup table of bytes that must be escaped. A value of true at index i means
 // that byte i requires an escape sequence in the input.
 static ESCAPE: [bool; 256] = {
-    const CT: bool = true; // control character \x00...\x1F
+    const CT: bool = true; // control character \x00..=\x1F
     const QU: bool = true; // quote \x22
     const BS: bool = true; // backslash \x5C
     const __: bool = false; // allow unescaped
@@ -700,7 +708,7 @@
 };
 
 fn next_or_eof<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result<u8> {
-    match try!(read.next()) {
+    match tri!(read.next()) {
         Some(b) => Ok(b),
         None => error(read, ErrorCode::EofWhileParsingString),
     }
@@ -718,7 +726,7 @@
 /// Parses a JSON escape sequence and appends it into the scratch space. Assumes
 /// the previous byte read was a backslash.
 fn parse_escape<'de, R: Read<'de>>(read: &mut R, scratch: &mut Vec<u8>) -> Result<()> {
-    let ch = try!(next_or_eof(read));
+    let ch = tri!(next_or_eof(read));
 
     match ch {
         b'"' => scratch.push(b'"'),
@@ -730,22 +738,22 @@
         b'r' => scratch.push(b'\r'),
         b't' => scratch.push(b'\t'),
         b'u' => {
-            let c = match try!(read.decode_hex_escape()) {
-                0xDC00...0xDFFF => {
+            let c = match tri!(read.decode_hex_escape()) {
+                0xDC00..=0xDFFF => {
                     return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
                 }
 
                 // Non-BMP characters are encoded as a sequence of
                 // two hex escapes, representing UTF-16 surrogates.
-                n1 @ 0xD800...0xDBFF => {
-                    if try!(next_or_eof(read)) != b'\\' {
+                n1 @ 0xD800..=0xDBFF => {
+                    if tri!(next_or_eof(read)) != b'\\' {
                         return error(read, ErrorCode::UnexpectedEndOfHexEscape);
                     }
-                    if try!(next_or_eof(read)) != b'u' {
+                    if tri!(next_or_eof(read)) != b'u' {
                         return error(read, ErrorCode::UnexpectedEndOfHexEscape);
                     }
 
-                    let n2 = try!(read.decode_hex_escape());
+                    let n2 = tri!(read.decode_hex_escape());
 
                     if n2 < 0xDC00 || n2 > 0xDFFF {
                         return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
@@ -782,27 +790,27 @@
 /// Parses a JSON escape sequence and discards the value. Assumes the previous
 /// byte read was a backslash.
 fn ignore_escape<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result<()> {
-    let ch = try!(next_or_eof(read));
+    let ch = tri!(next_or_eof(read));
 
     match ch {
         b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {}
         b'u' => {
-            let n = match try!(read.decode_hex_escape()) {
-                0xDC00...0xDFFF => {
+            let n = match tri!(read.decode_hex_escape()) {
+                0xDC00..=0xDFFF => {
                     return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
                 }
 
                 // Non-BMP characters are encoded as a sequence of
                 // two hex escapes, representing UTF-16 surrogates.
-                n1 @ 0xD800...0xDBFF => {
-                    if try!(next_or_eof(read)) != b'\\' {
+                n1 @ 0xD800..=0xDBFF => {
+                    if tri!(next_or_eof(read)) != b'\\' {
                         return error(read, ErrorCode::UnexpectedEndOfHexEscape);
                     }
-                    if try!(next_or_eof(read)) != b'u' {
+                    if tri!(next_or_eof(read)) != b'u' {
                         return error(read, ErrorCode::UnexpectedEndOfHexEscape);
                     }
 
-                    let n2 = try!(read.decode_hex_escape());
+                    let n2 = tri!(read.decode_hex_escape());
 
                     if n2 < 0xDC00 || n2 > 0xDFFF {
                         return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
diff --git a/src/ser.rs b/src/ser.rs
index cfae381..1387e6c 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,15 +1,11 @@
 //! Serialize a Rust data structure into JSON data.
 
-use std::fmt;
-use std::io;
-use std::num::FpCategory;
-use std::str;
-
-use super::error::{Error, ErrorCode, Result};
+use crate::error::{Error, ErrorCode, Result};
+use crate::io;
+use crate::lib::num::FpCategory;
+use crate::lib::*;
 use serde::ser::{self, Impossible, Serialize};
-
-use itoa;
-use ryu;
+use serde::serde_if_integer128;
 
 /// A structure for serializing Rust values into JSON.
 pub struct Serializer<W, F = CompactFormatter> {
@@ -79,7 +75,7 @@
 
     #[inline]
     fn serialize_bool(self, value: bool) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_bool(&mut self.writer, value)
             .map_err(Error::io));
@@ -88,7 +84,7 @@
 
     #[inline]
     fn serialize_i8(self, value: i8) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_i8(&mut self.writer, value)
             .map_err(Error::io));
@@ -97,7 +93,7 @@
 
     #[inline]
     fn serialize_i16(self, value: i16) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_i16(&mut self.writer, value)
             .map_err(Error::io));
@@ -106,7 +102,7 @@
 
     #[inline]
     fn serialize_i32(self, value: i32) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_i32(&mut self.writer, value)
             .map_err(Error::io));
@@ -115,7 +111,7 @@
 
     #[inline]
     fn serialize_i64(self, value: i64) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_i64(&mut self.writer, value)
             .map_err(Error::io));
@@ -132,7 +128,7 @@
 
     #[inline]
     fn serialize_u8(self, value: u8) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_u8(&mut self.writer, value)
             .map_err(Error::io));
@@ -141,7 +137,7 @@
 
     #[inline]
     fn serialize_u16(self, value: u16) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_u16(&mut self.writer, value)
             .map_err(Error::io));
@@ -150,7 +146,7 @@
 
     #[inline]
     fn serialize_u32(self, value: u32) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_u32(&mut self.writer, value)
             .map_err(Error::io));
@@ -159,7 +155,7 @@
 
     #[inline]
     fn serialize_u64(self, value: u64) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_u64(&mut self.writer, value)
             .map_err(Error::io));
@@ -178,13 +174,13 @@
     fn serialize_f32(self, value: f32) -> Result<()> {
         match value.classify() {
             FpCategory::Nan | FpCategory::Infinite => {
-                try!(self
+                tri!(self
                     .formatter
                     .write_null(&mut self.writer)
                     .map_err(Error::io));
             }
             _ => {
-                try!(self
+                tri!(self
                     .formatter
                     .write_f32(&mut self.writer, value)
                     .map_err(Error::io));
@@ -197,13 +193,13 @@
     fn serialize_f64(self, value: f64) -> Result<()> {
         match value.classify() {
             FpCategory::Nan | FpCategory::Infinite => {
-                try!(self
+                tri!(self
                     .formatter
                     .write_null(&mut self.writer)
                     .map_err(Error::io));
             }
             _ => {
-                try!(self
+                tri!(self
                     .formatter
                     .write_f64(&mut self.writer, value)
                     .map_err(Error::io));
@@ -221,23 +217,23 @@
 
     #[inline]
     fn serialize_str(self, value: &str) -> Result<()> {
-        try!(format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io));
+        tri!(format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io));
         Ok(())
     }
 
     #[inline]
     fn serialize_bytes(self, value: &[u8]) -> Result<()> {
         use serde::ser::SerializeSeq;
-        let mut seq = try!(self.serialize_seq(Some(value.len())));
+        let mut seq = tri!(self.serialize_seq(Some(value.len())));
         for byte in value {
-            try!(seq.serialize_element(byte));
+            tri!(seq.serialize_element(byte));
         }
         seq.end()
     }
 
     #[inline]
     fn serialize_unit(self) -> Result<()> {
-        try!(self
+        tri!(self
             .formatter
             .write_null(&mut self.writer)
             .map_err(Error::io));
@@ -279,29 +275,29 @@
     where
         T: Serialize,
     {
-        try!(self
+        tri!(self
             .formatter
             .begin_object(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .begin_object_key(&mut self.writer, true)
             .map_err(Error::io));
-        try!(self.serialize_str(variant));
-        try!(self
+        tri!(self.serialize_str(variant));
+        tri!(self
             .formatter
             .end_object_key(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .begin_object_value(&mut self.writer)
             .map_err(Error::io));
-        try!(value.serialize(&mut *self));
-        try!(self
+        tri!(value.serialize(&mut *self));
+        tri!(self
             .formatter
             .end_object_value(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .end_object(&mut self.writer)
             .map_err(Error::io));
@@ -324,11 +320,11 @@
     #[inline]
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
         if len == Some(0) {
-            try!(self
+            tri!(self
                 .formatter
                 .begin_array(&mut self.writer)
                 .map_err(Error::io));
-            try!(self
+            tri!(self
                 .formatter
                 .end_array(&mut self.writer)
                 .map_err(Error::io));
@@ -337,7 +333,7 @@
                 state: State::Empty,
             })
         } else {
-            try!(self
+            tri!(self
                 .formatter
                 .begin_array(&mut self.writer)
                 .map_err(Error::io));
@@ -370,20 +366,20 @@
         variant: &'static str,
         len: usize,
     ) -> Result<Self::SerializeTupleVariant> {
-        try!(self
+        tri!(self
             .formatter
             .begin_object(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .begin_object_key(&mut self.writer, true)
             .map_err(Error::io));
-        try!(self.serialize_str(variant));
-        try!(self
+        tri!(self.serialize_str(variant));
+        tri!(self
             .formatter
             .end_object_key(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .begin_object_value(&mut self.writer)
             .map_err(Error::io));
@@ -393,11 +389,11 @@
     #[inline]
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
         if len == Some(0) {
-            try!(self
+            tri!(self
                 .formatter
                 .begin_object(&mut self.writer)
                 .map_err(Error::io));
-            try!(self
+            tri!(self
                 .formatter
                 .end_object(&mut self.writer)
                 .map_err(Error::io));
@@ -406,7 +402,7 @@
                 state: State::Empty,
             })
         } else {
-            try!(self
+            tri!(self
                 .formatter
                 .begin_object(&mut self.writer)
                 .map_err(Error::io));
@@ -421,9 +417,9 @@
     fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
         match name {
             #[cfg(feature = "arbitrary_precision")]
-            ::number::TOKEN => Ok(Compound::Number { ser: self }),
+            crate::number::TOKEN => Ok(Compound::Number { ser: self }),
             #[cfg(feature = "raw_value")]
-            ::raw::TOKEN => Ok(Compound::RawValue { ser: self }),
+            crate::raw::TOKEN => Ok(Compound::RawValue { ser: self }),
             _ => self.serialize_map(Some(len)),
         }
     }
@@ -436,20 +432,20 @@
         variant: &'static str,
         len: usize,
     ) -> Result<Self::SerializeStructVariant> {
-        try!(self
+        tri!(self
             .formatter
             .begin_object(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .begin_object_key(&mut self.writer, true)
             .map_err(Error::io));
-        try!(self.serialize_str(variant));
-        try!(self
+        tri!(self.serialize_str(variant));
+        tri!(self
             .formatter
             .end_object_key(&mut self.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .formatter
             .begin_object_value(&mut self.writer)
             .map_err(Error::io));
@@ -460,7 +456,7 @@
     where
         T: fmt::Display,
     {
-        use std::fmt::Write;
+        use self::fmt::Write;
 
         struct Adapter<'ser, W: 'ser, F: 'ser> {
             writer: &'ser mut W,
@@ -485,7 +481,7 @@
             }
         }
 
-        try!(self
+        tri!(self
             .formatter
             .begin_string(&mut self.writer)
             .map_err(Error::io));
@@ -502,7 +498,7 @@
                 }
             }
         }
-        try!(self
+        tri!(self
             .formatter
             .end_string(&mut self.writer)
             .map_err(Error::io));
@@ -510,16 +506,16 @@
     }
 }
 
-#[derive(Eq, PartialEq)]
-/// Not public API. Should be pub(crate).
+// Not public API. Should be pub(crate).
 #[doc(hidden)]
+#[derive(Eq, PartialEq)]
 pub enum State {
     Empty,
     First,
     Rest,
 }
 
-/// Not public API. Should be pub(crate).
+// Not public API. Should be pub(crate).
 #[doc(hidden)]
 pub enum Compound<'a, W: 'a, F: 'a> {
     Map {
@@ -550,13 +546,13 @@
                 ref mut ser,
                 ref mut state,
             } => {
-                try!(ser
+                tri!(ser
                     .formatter
                     .begin_array_value(&mut ser.writer, *state == State::First)
                     .map_err(Error::io));
                 *state = State::Rest;
-                try!(value.serialize(&mut **ser));
-                try!(ser
+                tri!(value.serialize(&mut **ser));
+                tri!(ser
                     .formatter
                     .end_array_value(&mut ser.writer)
                     .map_err(Error::io));
@@ -575,7 +571,7 @@
             Compound::Map { ser, state } => {
                 match state {
                     State::Empty => {}
-                    _ => try!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
+                    _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
                 }
                 Ok(())
             }
@@ -653,13 +649,13 @@
             Compound::Map { ser, state } => {
                 match state {
                     State::Empty => {}
-                    _ => try!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
+                    _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
                 }
-                try!(ser
+                tri!(ser
                     .formatter
                     .end_object_value(&mut ser.writer)
                     .map_err(Error::io));
-                try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
+                tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
                 Ok(())
             }
             #[cfg(feature = "arbitrary_precision")]
@@ -688,15 +684,15 @@
                 ref mut ser,
                 ref mut state,
             } => {
-                try!(ser
+                tri!(ser
                     .formatter
                     .begin_object_key(&mut ser.writer, *state == State::First)
                     .map_err(Error::io));
                 *state = State::Rest;
 
-                try!(key.serialize(MapKeySerializer { ser: *ser }));
+                tri!(key.serialize(MapKeySerializer { ser: *ser }));
 
-                try!(ser
+                tri!(ser
                     .formatter
                     .end_object_key(&mut ser.writer)
                     .map_err(Error::io));
@@ -716,12 +712,12 @@
     {
         match *self {
             Compound::Map { ref mut ser, .. } => {
-                try!(ser
+                tri!(ser
                     .formatter
                     .begin_object_value(&mut ser.writer)
                     .map_err(Error::io));
-                try!(value.serialize(&mut **ser));
-                try!(ser
+                tri!(value.serialize(&mut **ser));
+                tri!(ser
                     .formatter
                     .end_object_value(&mut ser.writer)
                     .map_err(Error::io));
@@ -740,7 +736,7 @@
             Compound::Map { ser, state } => {
                 match state {
                     State::Empty => {}
-                    _ => try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
+                    _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
                 }
                 Ok(())
             }
@@ -767,13 +763,13 @@
     {
         match *self {
             Compound::Map { .. } => {
-                try!(ser::SerializeMap::serialize_key(self, key));
+                tri!(ser::SerializeMap::serialize_key(self, key));
                 ser::SerializeMap::serialize_value(self, value)
             }
             #[cfg(feature = "arbitrary_precision")]
             Compound::Number { ref mut ser, .. } => {
-                if key == ::number::TOKEN {
-                    try!(value.serialize(NumberStrEmitter(&mut *ser)));
+                if key == crate::number::TOKEN {
+                    tri!(value.serialize(NumberStrEmitter(&mut *ser)));
                     Ok(())
                 } else {
                     Err(invalid_number())
@@ -781,8 +777,8 @@
             }
             #[cfg(feature = "raw_value")]
             Compound::RawValue { ref mut ser, .. } => {
-                if key == ::raw::TOKEN {
-                    try!(value.serialize(RawValueStrEmitter(&mut *ser)));
+                if key == crate::raw::TOKEN {
+                    tri!(value.serialize(RawValueStrEmitter(&mut *ser)));
                     Ok(())
                 } else {
                     Err(invalid_raw_value())
@@ -831,13 +827,13 @@
             Compound::Map { ser, state } => {
                 match state {
                     State::Empty => {}
-                    _ => try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
+                    _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
                 }
-                try!(ser
+                tri!(ser
                     .formatter
                     .end_object_value(&mut ser.writer)
                     .map_err(Error::io));
-                try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
+                tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
                 Ok(())
             }
             #[cfg(feature = "arbitrary_precision")]
@@ -910,17 +906,17 @@
     }
 
     fn serialize_i8(self, value: i8) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_i8(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -929,17 +925,17 @@
     }
 
     fn serialize_i16(self, value: i16) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_i16(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -948,17 +944,17 @@
     }
 
     fn serialize_i32(self, value: i32) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_i32(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -967,17 +963,17 @@
     }
 
     fn serialize_i64(self, value: i64) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_i64(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -987,17 +983,17 @@
 
     serde_if_integer128! {
         fn serialize_i128(self, value: i128) -> Result<()> {
-            try!(self
+            tri!(self
                 .ser
                 .formatter
                 .begin_string(&mut self.ser.writer)
                 .map_err(Error::io));
-            try!(self
+            tri!(self
                 .ser
                 .formatter
                 .write_number_str(&mut self.ser.writer, &value.to_string())
                 .map_err(Error::io));
-            try!(self
+            tri!(self
                 .ser
                 .formatter
                 .end_string(&mut self.ser.writer)
@@ -1007,17 +1003,17 @@
     }
 
     fn serialize_u8(self, value: u8) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_u8(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -1026,17 +1022,17 @@
     }
 
     fn serialize_u16(self, value: u16) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_u16(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -1045,17 +1041,17 @@
     }
 
     fn serialize_u32(self, value: u32) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_u32(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -1064,17 +1060,17 @@
     }
 
     fn serialize_u64(self, value: u64) -> Result<()> {
-        try!(self
+        tri!(self
             .ser
             .formatter
             .begin_string(&mut self.ser.writer)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .write_u64(&mut self.ser.writer, value)
             .map_err(Error::io));
-        try!(self
+        tri!(self
             .ser
             .formatter
             .end_string(&mut self.ser.writer)
@@ -1084,17 +1080,17 @@
 
     serde_if_integer128! {
         fn serialize_u128(self, value: u128) -> Result<()> {
-            try!(self
+            tri!(self
                 .ser
                 .formatter
                 .begin_string(&mut self.ser.writer)
                 .map_err(Error::io));
-            try!(self
+            tri!(self
                 .ser
                 .formatter
                 .write_number_str(&mut self.ser.writer, &value.to_string())
                 .map_err(Error::io));
-            try!(self
+            tri!(self
                 .ser
                 .formatter
                 .end_string(&mut self.ser.writer)
@@ -1638,7 +1634,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `-123` to the specified writer.
@@ -1647,7 +1645,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `-123` to the specified writer.
@@ -1656,7 +1656,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `-123` to the specified writer.
@@ -1665,7 +1667,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `123` to the specified writer.
@@ -1674,7 +1678,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `123` to the specified writer.
@@ -1683,7 +1689,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `123` to the specified writer.
@@ -1692,7 +1700,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes an integer value like `123` to the specified writer.
@@ -1701,7 +1711,9 @@
     where
         W: io::Write,
     {
-        itoa::write(writer, value).map(drop)
+        let mut buffer = itoa::Buffer::new();
+        let s = buffer.format(value);
+        writer.write_all(s.as_bytes())
     }
 
     /// Writes a floating point value like `-31.26e+12` to the specified writer.
@@ -1976,8 +1988,8 @@
         self.current_indent -= 1;
 
         if self.has_value {
-            try!(writer.write_all(b"\n"));
-            try!(indent(writer, self.current_indent, self.indent));
+            tri!(writer.write_all(b"\n"));
+            tri!(indent(writer, self.current_indent, self.indent));
         }
 
         writer.write_all(b"]")
@@ -1989,11 +2001,11 @@
         W: io::Write,
     {
         if first {
-            try!(writer.write_all(b"\n"));
+            tri!(writer.write_all(b"\n"));
         } else {
-            try!(writer.write_all(b",\n"));
+            tri!(writer.write_all(b",\n"));
         }
-        try!(indent(writer, self.current_indent, self.indent));
+        tri!(indent(writer, self.current_indent, self.indent));
         Ok(())
     }
 
@@ -2024,8 +2036,8 @@
         self.current_indent -= 1;
 
         if self.has_value {
-            try!(writer.write_all(b"\n"));
-            try!(indent(writer, self.current_indent, self.indent));
+            tri!(writer.write_all(b"\n"));
+            tri!(indent(writer, self.current_indent, self.indent));
         }
 
         writer.write_all(b"}")
@@ -2037,9 +2049,9 @@
         W: io::Write,
     {
         if first {
-            try!(writer.write_all(b"\n"));
+            tri!(writer.write_all(b"\n"));
         } else {
-            try!(writer.write_all(b",\n"));
+            tri!(writer.write_all(b",\n"));
         }
         indent(writer, self.current_indent, self.indent)
     }
@@ -2071,9 +2083,9 @@
     W: io::Write,
     F: Formatter,
 {
-    try!(formatter.begin_string(writer));
-    try!(format_escaped_str_contents(writer, formatter, value));
-    try!(formatter.end_string(writer));
+    tri!(formatter.begin_string(writer));
+    tri!(format_escaped_str_contents(writer, formatter, value));
+    tri!(formatter.end_string(writer));
     Ok(())
 }
 
@@ -2097,17 +2109,17 @@
         }
 
         if start < i {
-            try!(formatter.write_string_fragment(writer, &value[start..i]));
+            tri!(formatter.write_string_fragment(writer, &value[start..i]));
         }
 
         let char_escape = CharEscape::from_escape_table(escape, byte);
-        try!(formatter.write_char_escape(writer, char_escape));
+        tri!(formatter.write_char_escape(writer, char_escape));
 
         start = i + 1;
     }
 
     if start != bytes.len() {
-        try!(formatter.write_string_fragment(writer, &value[start..]));
+        tri!(formatter.write_string_fragment(writer, &value[start..]));
     }
 
     Ok(())
@@ -2158,7 +2170,7 @@
     T: Serialize,
 {
     let mut ser = Serializer::new(writer);
-    try!(value.serialize(&mut ser));
+    tri!(value.serialize(&mut ser));
     Ok(())
 }
 
@@ -2176,7 +2188,7 @@
     T: Serialize,
 {
     let mut ser = Serializer::pretty(writer);
-    try!(value.serialize(&mut ser));
+    tri!(value.serialize(&mut ser));
     Ok(())
 }
 
@@ -2192,7 +2204,7 @@
     T: Serialize,
 {
     let mut writer = Vec::with_capacity(128);
-    try!(to_writer(&mut writer, value));
+    tri!(to_writer(&mut writer, value));
     Ok(writer)
 }
 
@@ -2208,7 +2220,7 @@
     T: Serialize,
 {
     let mut writer = Vec::with_capacity(128);
-    try!(to_writer_pretty(&mut writer, value));
+    tri!(to_writer_pretty(&mut writer, value));
     Ok(writer)
 }
 
@@ -2223,7 +2235,7 @@
 where
     T: Serialize,
 {
-    let vec = try!(to_vec(value));
+    let vec = tri!(to_vec(value));
     let string = unsafe {
         // We do not emit invalid UTF-8.
         String::from_utf8_unchecked(vec)
@@ -2242,7 +2254,7 @@
 where
     T: Serialize,
 {
-    let vec = try!(to_vec_pretty(value));
+    let vec = tri!(to_vec_pretty(value));
     let string = unsafe {
         // We do not emit invalid UTF-8.
         String::from_utf8_unchecked(vec)
@@ -2255,7 +2267,7 @@
     W: io::Write,
 {
     for _ in 0..n {
-        try!(wr.write_all(s));
+        tri!(wr.write_all(s));
     }
 
     Ok(())
diff --git a/src/value/de.rs b/src/value/de.rs
index c1f0810..8e41dda 100644
--- a/src/value/de.rs
+++ b/src/value/de.rs
@@ -1,24 +1,17 @@
-use std::borrow::Cow;
-use std::fmt;
-use std::slice;
-use std::str;
-use std::vec;
-
-use serde;
+use crate::error::Error;
+use crate::lib::str::FromStr;
+use crate::lib::*;
+use crate::map::Map;
+use crate::number::Number;
+use crate::value::Value;
 use serde::de::{
-    Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess,
-    Unexpected, VariantAccess, Visitor,
+    self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
+    SeqAccess, Unexpected, VariantAccess, Visitor,
 };
-
-use error::Error;
-use map::Map;
-use number::Number;
-use value::Value;
-
-use serde::de;
+use serde::{forward_to_deserialize_any, serde_if_integer128};
 
 #[cfg(feature = "arbitrary_precision")]
-use number::NumberFromString;
+use crate::number::NumberFromString;
 
 impl<'de> Deserialize<'de> for Value {
     #[inline]
@@ -93,7 +86,7 @@
             {
                 let mut vec = Vec::new();
 
-                while let Some(elem) = try!(visitor.next_element()) {
+                while let Some(elem) = tri!(visitor.next_element()) {
                     vec.push(elem);
                 }
 
@@ -112,14 +105,14 @@
                     }
                     #[cfg(feature = "raw_value")]
                     Some(KeyClass::RawValue) => {
-                        let value = visitor.next_value_seed(::raw::BoxedFromString)?;
-                        ::from_str(value.get()).map_err(de::Error::custom)
+                        let value = visitor.next_value_seed(crate::raw::BoxedFromString)?;
+                        crate::from_str(value.get()).map_err(de::Error::custom)
                     }
                     Some(KeyClass::Map(first_key)) => {
                         let mut values = Map::new();
 
-                        values.insert(first_key, try!(visitor.next_value()));
-                        while let Some((key, value)) = try!(visitor.next_entry()) {
+                        values.insert(first_key, tri!(visitor.next_value()));
+                        while let Some((key, value)) = tri!(visitor.next_entry()) {
                             values.insert(key, value);
                         }
 
@@ -134,7 +127,7 @@
     }
 }
 
-impl str::FromStr for Value {
+impl FromStr for Value {
     type Err = Error;
     fn from_str(s: &str) -> Result<Value, Error> {
         super::super::de::from_str(s)
@@ -173,7 +166,7 @@
 {
     let len = array.len();
     let mut deserializer = SeqDeserializer::new(array);
-    let seq = try!(visitor.visit_seq(&mut deserializer));
+    let seq = tri!(visitor.visit_seq(&mut deserializer));
     let remaining = deserializer.iter.len();
     if remaining == 0 {
         Ok(seq)
@@ -191,7 +184,7 @@
 {
     let len = object.len();
     let mut deserializer = MapDeserializer::new(object);
-    let map = try!(visitor.visit_map(&mut deserializer));
+    let map = tri!(visitor.visit_map(&mut deserializer));
     let remaining = deserializer.iter.len();
     if remaining == 0 {
         Ok(map)
@@ -305,8 +298,8 @@
     {
         #[cfg(feature = "raw_value")]
         {
-            if name == ::raw::TOKEN {
-                return visitor.visit_map(::raw::OwnedRawDeserializer {
+            if name == crate::raw::TOKEN {
+                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
                     raw_value: Some(self.to_string()),
                 });
             }
@@ -581,7 +574,7 @@
         if len == 0 {
             visitor.visit_unit()
         } else {
-            let ret = try!(visitor.visit_seq(&mut self));
+            let ret = tri!(visitor.visit_seq(&mut self));
             let remaining = self.iter.len();
             if remaining == 0 {
                 Ok(ret)
@@ -723,7 +716,7 @@
 {
     let len = array.len();
     let mut deserializer = SeqRefDeserializer::new(array);
-    let seq = try!(visitor.visit_seq(&mut deserializer));
+    let seq = tri!(visitor.visit_seq(&mut deserializer));
     let remaining = deserializer.iter.len();
     if remaining == 0 {
         Ok(seq)
@@ -741,7 +734,7 @@
 {
     let len = object.len();
     let mut deserializer = MapRefDeserializer::new(object);
-    let map = try!(visitor.visit_map(&mut deserializer));
+    let map = tri!(visitor.visit_map(&mut deserializer));
     let remaining = deserializer.iter.len();
     if remaining == 0 {
         Ok(map)
@@ -852,8 +845,8 @@
     {
         #[cfg(feature = "raw_value")]
         {
-            if name == ::raw::TOKEN {
-                return visitor.visit_map(::raw::OwnedRawDeserializer {
+            if name == crate::raw::TOKEN {
+                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
                     raw_value: Some(self.to_string()),
                 });
             }
@@ -1117,7 +1110,7 @@
         if len == 0 {
             visitor.visit_unit()
         } else {
-            let ret = try!(visitor.visit_seq(&mut self));
+            let ret = tri!(visitor.visit_seq(&mut self));
             let remaining = self.iter.len();
             if remaining == 0 {
                 Ok(ret)
@@ -1345,9 +1338,9 @@
     {
         match s {
             #[cfg(feature = "arbitrary_precision")]
-            ::number::TOKEN => Ok(KeyClass::Number),
+            crate::number::TOKEN => Ok(KeyClass::Number),
             #[cfg(feature = "raw_value")]
-            ::raw::TOKEN => Ok(KeyClass::RawValue),
+            crate::raw::TOKEN => Ok(KeyClass::RawValue),
             _ => Ok(KeyClass::Map(s.to_owned())),
         }
     }
@@ -1358,9 +1351,9 @@
     {
         match s.as_str() {
             #[cfg(feature = "arbitrary_precision")]
-            ::number::TOKEN => Ok(KeyClass::Number),
+            crate::number::TOKEN => Ok(KeyClass::Number),
             #[cfg(feature = "raw_value")]
-            ::raw::TOKEN => Ok(KeyClass::RawValue),
+            crate::raw::TOKEN => Ok(KeyClass::RawValue),
             _ => Ok(KeyClass::Map(s)),
         }
     }
@@ -1368,7 +1361,7 @@
 
 impl Value {
     #[cold]
-    fn invalid_type<E>(&self, exp: &Expected) -> E
+    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
     where
         E: serde::de::Error,
     {
diff --git a/src/value/from.rs b/src/value/from.rs
index 4b93f09..2e2ac47 100644
--- a/src/value/from.rs
+++ b/src/value/from.rs
@@ -1,8 +1,11 @@
-use std::borrow::Cow;
-
 use super::Value;
-use map::Map;
-use number::Number;
+use crate::lib::iter::FromIterator;
+use crate::lib::*;
+use crate::map::Map;
+use crate::number::Number;
+
+#[cfg(feature = "arbitrary_precision")]
+use serde::serde_if_integer128;
 
 macro_rules! from_integer {
     ($($ty:ident)*) => {
@@ -33,7 +36,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let f: f32 = 13.37;
@@ -49,7 +52,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let f: f64 = 13.37;
@@ -65,7 +68,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let b = false;
@@ -81,7 +84,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let s: String = "lorem".to_string();
@@ -97,7 +100,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let s: &str = "lorem";
@@ -113,7 +116,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     /// use std::borrow::Cow;
     ///
@@ -121,7 +124,7 @@
     /// let x: Value = s.into();
     /// ```
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     /// use std::borrow::Cow;
     ///
@@ -138,7 +141,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::{Map, Value};
     ///
     /// let mut m = Map::new();
@@ -155,7 +158,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let v = vec!["lorem", "ipsum", "dolor"];
@@ -171,7 +174,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
@@ -182,26 +185,26 @@
     }
 }
 
-impl<T: Into<Value>> ::std::iter::FromIterator<T> for Value {
+impl<T: Into<Value>> FromIterator<T> for Value {
     /// Convert an iteratable type to a `Value`
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let v = std::iter::repeat(42).take(5);
     /// let x: Value = v.collect();
     /// ```
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
     /// let x: Value = v.into_iter().collect();
     /// ```
     ///
-    /// ```edition2018
+    /// ```
     /// use std::iter::FromIterator;
     /// use serde_jsonrc::Value;
     ///
@@ -217,7 +220,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// let u = ();
diff --git a/src/value/index.rs b/src/value/index.rs
index dba13bd..15e0114 100644
--- a/src/value/index.rs
+++ b/src/value/index.rs
@@ -1,8 +1,6 @@
-use std::fmt;
-use std::ops;
-
 use super::Value;
-use map::Map;
+use crate::lib::*;
+use crate::map::Map;
 
 /// A type that can be used to index into a `serde_jsonrc::Value`.
 ///
@@ -20,7 +18,7 @@
 ///
 /// # Examples
 ///
-/// ```edition2018
+/// ```
 /// # use serde_jsonrc::json;
 /// #
 /// let data = json!({ "inner": [1, 2, 3] });
@@ -135,7 +133,7 @@
     pub trait Sealed {}
     impl Sealed for usize {}
     impl Sealed for str {}
-    impl Sealed for String {}
+    impl Sealed for super::String {}
     impl<'a, T: ?Sized> Sealed for &'a T where T: Sealed {}
 }
 
@@ -193,7 +191,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let data = json!({
@@ -232,7 +230,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut data = json!({ "x": 0 });
diff --git a/src/value/mod.rs b/src/value/mod.rs
index b61d358..5ff3729 100644
--- a/src/value/mod.rs
+++ b/src/value/mod.rs
@@ -5,7 +5,7 @@
 //! Serde jsonrc provides a [`json!` macro][macro] to build `serde_jsonrc::Value`
 //! objects with very natural JSON syntax.
 //!
-//! ```edition2018
+//! ```
 //! use serde_jsonrc::json;
 //!
 //! fn main() {
@@ -34,7 +34,7 @@
 //! will check at compile time that the value you are interpolating is able to
 //! be represented as JSON.
 //!
-//! ```edition2018
+//! ```
 //! # use serde_jsonrc::json;
 //! #
 //! # fn random_phone() -> u16 { 0 }
@@ -58,7 +58,7 @@
 //! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
 //! a TCP stream.
 //!
-//! ```edition2018
+//! ```
 //! use serde_jsonrc::{json, Value, Error};
 //!
 //! fn untyped_example() -> Result<(), Error> {
@@ -90,24 +90,19 @@
 //! [from_slice]: https://docs.serde.rs/serde_jsonrc/de/fn.from_slice.html
 //! [from_reader]: https://docs.serde.rs/serde_jsonrc/de/fn.from_reader.html
 
-use std::fmt::{self, Debug};
-use std::io;
-use std::mem;
-use std::str;
-
+use self::ser::Serializer;
+use crate::error::Error;
+use crate::io;
+use crate::lib::*;
 use serde::de::DeserializeOwned;
 use serde::ser::Serialize;
 
-use error::Error;
-pub use map::Map;
-pub use number::Number;
+pub use self::index::Index;
+pub use crate::map::Map;
+pub use crate::number::Number;
 
 #[cfg(feature = "raw_value")]
-pub use raw::RawValue;
-
-pub use self::index::Index;
-
-use self::ser::Serializer;
+pub use crate::raw::RawValue;
 
 /// Represents any valid JSON value.
 ///
@@ -116,7 +111,7 @@
 pub enum Value {
     /// Represents a JSON null value.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!(null);
@@ -125,7 +120,7 @@
 
     /// Represents a JSON boolean.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!(true);
@@ -134,7 +129,7 @@
 
     /// Represents a JSON number, whether integer or floating point.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!(12.5);
@@ -143,7 +138,7 @@
 
     /// Represents a JSON string.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!("a string");
@@ -152,7 +147,7 @@
 
     /// Represents a JSON array.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!(["an", "array"]);
@@ -167,7 +162,7 @@
     /// allows JSON data to be deserialized into a Value and serialized to a
     /// string while retaining the order of map keys in the input.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "an": "object" });
@@ -199,8 +194,8 @@
             // maps it to fmt::Error
             io::Error::new(io::ErrorKind::Other, "fmt error")
         }
-        let s = try!(str::from_utf8(buf).map_err(io_error));
-        try!(self.inner.write_str(s).map_err(io_error));
+        let s = tri!(str::from_utf8(buf).map_err(io_error));
+        tri!(self.inner.write_str(s).map_err(io_error));
         Ok(buf.len())
     }
 
@@ -212,7 +207,7 @@
 impl fmt::Display for Value {
     /// Display a JSON value as a string.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let json = json!({ "city": "London", "street": "10 Downing Street" });
@@ -264,7 +259,7 @@
     /// number. Also returns `None` if the given key does not exist in the map
     /// or the given index is not within the bounds of the array.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let object = json!({ "A": 65, "B": 66, "C": 67 });
@@ -280,7 +275,7 @@
     /// way. This returns `Value::Null` in cases where `get` would have returned
     /// `None`.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let object = json!({
@@ -306,7 +301,7 @@
     /// number. Also returns `None` if the given key does not exist in the map
     /// or the given index is not within the bounds of the array.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut object = json!({ "A": 65, "B": 66, "C": 67 });
@@ -325,7 +320,7 @@
     /// `as_object_mut` are guaranteed to return the map representation of the
     /// object.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });
@@ -343,7 +338,7 @@
     /// If the `Value` is an Object, returns the associated Map. Returns None
     /// otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });
@@ -364,7 +359,7 @@
     /// If the `Value` is an Object, returns the associated mutable Map.
     /// Returns None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut v = json!({ "a": { "nested": true } });
@@ -385,7 +380,7 @@
     /// `as_array_mut` are guaranteed to return the vector representing the
     /// array.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });
@@ -402,7 +397,7 @@
     /// If the `Value` is an Array, returns the associated vector. Returns None
     /// otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });
@@ -423,7 +418,7 @@
     /// If the `Value` is an Array, returns the associated mutable vector.
     /// Returns None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut v = json!({ "a": ["an", "array"] });
@@ -443,7 +438,7 @@
     /// For any Value on which `is_string` returns true, `as_str` is guaranteed
     /// to return the string slice.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": "some string", "b": false });
@@ -460,7 +455,7 @@
     /// If the `Value` is a String, returns the associated str. Returns None
     /// otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": "some string", "b": false });
@@ -489,7 +484,7 @@
 
     /// Returns true if the `Value` is a Number. Returns false otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 1, "b": "2" });
@@ -512,7 +507,7 @@
     /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
     /// return the integer value.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let big = i64::max_value() as u64 + 10;
@@ -538,7 +533,7 @@
     /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
     /// return the integer value.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
@@ -566,7 +561,7 @@
     /// Currently this function returns true if and only if both `is_i64` and
     /// `is_u64` return false but this is not a guarantee in the future.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
@@ -587,7 +582,7 @@
     /// If the `Value` is an integer, represent it as i64 if possible. Returns
     /// None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let big = i64::max_value() as u64 + 10;
@@ -607,7 +602,7 @@
     /// If the `Value` is an integer, represent it as u64 if possible. Returns
     /// None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
@@ -626,7 +621,7 @@
     /// If the `Value` is a number, represent it as f64 if possible. Returns
     /// None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
@@ -647,7 +642,7 @@
     /// For any Value on which `is_boolean` returns true, `as_bool` is
     /// guaranteed to return the boolean value.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": false, "b": "false" });
@@ -664,7 +659,7 @@
     /// If the `Value` is a Boolean, returns the associated bool. Returns None
     /// otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": false, "b": "false" });
@@ -686,7 +681,7 @@
     /// For any Value on which `is_null` returns true, `as_null` is guaranteed
     /// to return `Some(())`.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": null, "b": false });
@@ -702,7 +697,7 @@
 
     /// If the `Value` is a Null, returns (). Returns None otherwise.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let v = json!({ "a": null, "b": false });
@@ -733,7 +728,7 @@
     ///
     /// # Examples
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let data = json!({
@@ -745,7 +740,7 @@
     /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
     /// assert_eq!(data.pointer("/a/b/c"), None);
     /// ```
-    pub fn pointer<'a>(&'a self, pointer: &str) -> Option<&'a Value> {
+    pub fn pointer(&self, pointer: &str) -> Option<&Value> {
         if pointer == "" {
             return Some(self);
         }
@@ -788,7 +783,7 @@
     ///
     /// # Example of Use
     ///
-    /// ```edition2018
+    /// ```
     /// use serde_jsonrc::Value;
     ///
     /// fn main() {
@@ -801,6 +796,8 @@
     ///     *value.pointer_mut("/x").unwrap() = 1.5.into();
     ///     // Check that new value was written
     ///     assert_eq!(value.pointer("/x"), Some(&1.5.into()));
+    ///     // Or change the value only if it exists
+    ///     value.pointer_mut("/x").map(|v| *v = 1.5.into());
     ///
     ///     // "Steal" ownership of a value. Can replace with any valid Value.
     ///     let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
@@ -808,7 +805,7 @@
     ///     assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
     /// }
     /// ```
-    pub fn pointer_mut<'a>(&'a mut self, pointer: &str) -> Option<&'a mut Value> {
+    pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value> {
         if pointer == "" {
             return Some(self);
         }
@@ -843,7 +840,7 @@
 
     /// Takes the value out of the `Value`, leaving a `Null` in its place.
     ///
-    /// ```edition2018
+    /// ```
     /// # use serde_jsonrc::json;
     /// #
     /// let mut v = json!({ "x": "y" });
@@ -861,7 +858,7 @@
 ///
 /// # Examples
 ///
-/// ```edition2018
+/// ```
 /// # use serde::Deserialize;
 /// use serde_jsonrc::Value;
 ///
@@ -901,7 +898,7 @@
 ///
 /// # Example
 ///
-/// ```edition2018
+/// ```
 /// use serde::Serialize;
 /// use serde_jsonrc::json;
 ///
@@ -939,7 +936,7 @@
 /// This conversion can fail if `T`'s implementation of `Serialize` decides to
 /// fail, or if `T` contains a map with non-string keys.
 ///
-/// ```edition2018
+/// ```
 /// use std::collections::BTreeMap;
 ///
 /// fn main() {
@@ -963,7 +960,7 @@
 ///
 /// # Example
 ///
-/// ```edition2018
+/// ```
 /// use serde::Deserialize;
 /// use serde_jsonrc::json;
 ///
diff --git a/src/value/partial_eq.rs b/src/value/partial_eq.rs
index cfcf957..354ea5a 100644
--- a/src/value/partial_eq.rs
+++ b/src/value/partial_eq.rs
@@ -1,4 +1,5 @@
 use super::Value;
+use crate::lib::*;
 
 fn eq_i64(value: &Value, other: i64) -> bool {
     value.as_i64().map_or(false, |i| i == other)
diff --git a/src/value/ser.rs b/src/value/ser.rs
index b0e09be..6b76b16 100644
--- a/src/value/ser.rs
+++ b/src/value/ser.rs
@@ -1,10 +1,12 @@
-use serde::ser::Impossible;
-use serde::{self, Serialize};
+use crate::error::{Error, ErrorCode};
+use crate::lib::*;
+use crate::map::Map;
+use crate::number::Number;
+use crate::value::{to_value, Value};
+use serde::ser::{Impossible, Serialize};
 
-use error::{Error, ErrorCode};
-use map::Map;
-use number::Number;
-use value::{to_value, Value};
+#[cfg(feature = "arbitrary_precision")]
+use serde::serde_if_integer128;
 
 impl Serialize for Value {
     #[inline]
@@ -20,10 +22,10 @@
             Value::Array(ref v) => v.serialize(serializer),
             Value::Object(ref m) => {
                 use serde::ser::SerializeMap;
-                let mut map = try!(serializer.serialize_map(Some(m.len())));
+                let mut map = tri!(serializer.serialize_map(Some(m.len())));
                 for (k, v) in m {
-                    try!(map.serialize_key(k));
-                    try!(map.serialize_value(v));
+                    tri!(map.serialize_key(k));
+                    tri!(map.serialize_value(v));
                 }
                 map.end()
             }
@@ -173,7 +175,7 @@
         T: Serialize,
     {
         let mut values = Map::new();
-        values.insert(String::from(variant), try!(to_value(&value)));
+        values.insert(String::from(variant), tri!(to_value(&value)));
         Ok(Value::Object(values))
     }
 
@@ -235,9 +237,9 @@
     ) -> Result<Self::SerializeStruct, Error> {
         match name {
             #[cfg(feature = "arbitrary_precision")]
-            ::number::TOKEN => Ok(SerializeMap::Number { out_value: None }),
+            crate::number::TOKEN => Ok(SerializeMap::Number { out_value: None }),
             #[cfg(feature = "raw_value")]
-            ::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }),
+            crate::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }),
             _ => self.serialize_map(Some(len)),
         }
     }
@@ -289,7 +291,7 @@
     where
         T: Serialize,
     {
-        self.vec.push(try!(to_value(&value)));
+        self.vec.push(tri!(to_value(&value)));
         Ok(())
     }
 
@@ -338,7 +340,7 @@
     where
         T: Serialize,
     {
-        self.vec.push(try!(to_value(&value)));
+        self.vec.push(tri!(to_value(&value)));
         Ok(())
     }
 
@@ -363,7 +365,7 @@
             SerializeMap::Map {
                 ref mut next_key, ..
             } => {
-                *next_key = Some(try!(key.serialize(MapKeySerializer)));
+                *next_key = Some(tri!(key.serialize(MapKeySerializer)));
                 Ok(())
             }
             #[cfg(feature = "arbitrary_precision")]
@@ -386,7 +388,7 @@
                 // Panic because this indicates a bug in the program rather than an
                 // expected failure.
                 let key = key.expect("serialize_value called before serialize_key");
-                map.insert(key, try!(to_value(&value)));
+                map.insert(key, tri!(to_value(&value)));
                 Ok(())
             }
             #[cfg(feature = "arbitrary_precision")]
@@ -600,12 +602,12 @@
     {
         match *self {
             SerializeMap::Map { .. } => {
-                try!(serde::ser::SerializeMap::serialize_key(self, key));
+                tri!(serde::ser::SerializeMap::serialize_key(self, key));
                 serde::ser::SerializeMap::serialize_value(self, value)
             }
             #[cfg(feature = "arbitrary_precision")]
             SerializeMap::Number { ref mut out_value } => {
-                if key == ::number::TOKEN {
+                if key == crate::number::TOKEN {
                     *out_value = Some(value.serialize(NumberValueEmitter)?);
                     Ok(())
                 } else {
@@ -614,7 +616,7 @@
             }
             #[cfg(feature = "raw_value")]
             SerializeMap::RawValue { ref mut out_value } => {
-                if key == ::raw::TOKEN {
+                if key == crate::raw::TOKEN {
                     *out_value = Some(value.serialize(RawValueEmitter)?);
                     Ok(())
                 } else {
@@ -647,7 +649,7 @@
     where
         T: Serialize,
     {
-        self.map.insert(String::from(key), try!(to_value(&value)));
+        self.map.insert(String::from(key), tri!(to_value(&value)));
         Ok(())
     }
 
@@ -730,7 +732,7 @@
     }
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
-        let n = try!(value.to_owned().parse());
+        let n = tri!(value.to_owned().parse());
         Ok(Value::Number(n))
     }
 
@@ -909,7 +911,7 @@
     }
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
-        ::from_str(value)
+        crate::from_str(value)
     }
 
     fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
diff --git a/tests/crate/Cargo.toml b/tests/crate/Cargo.toml
index d09de09..996ad03 100644
--- a/tests/crate/Cargo.toml
+++ b/tests/crate/Cargo.toml
@@ -1,16 +1,20 @@
 [package]
 name = "serde_json_test"
 version = "0.0.0"
+edition = "2018"
 publish = false
 
 [lib]
 path = "test.rs"
 
 [dependencies]
-serde_jsonrc = { path = "../.." }
+serde_jsonrc = { path = "../..", default-features = false }
 
 [features]
-arbitrary_precision = ["serde_jsonrc/arbitrary_precision"]
+default = ["std"]
+std = ["serde_jsonrc/std"]
+alloc = ["serde_jsonrc/alloc"]
 preserve_order = ["serde_jsonrc/preserve_order"]
+arbitrary_precision = ["serde_jsonrc/arbitrary_precision"]
 raw_value = ["serde_jsonrc/raw_value"]
 unbounded_depth = ["serde_jsonrc/unbounded_depth"]
diff --git a/tests/crate/test.rs b/tests/crate/test.rs
index d1ee3b8..373af7a 100644
--- a/tests/crate/test.rs
+++ b/tests/crate/test.rs
@@ -1,2 +1 @@
-extern crate serde_jsonrc;
 pub use serde_jsonrc::*;
diff --git a/tests/debug.rs b/tests/debug.rs
index 692c0fa..c55810c 100644
--- a/tests/debug.rs
+++ b/tests/debug.rs
@@ -1,7 +1,4 @@
-#[macro_use]
-extern crate serde_jsonrc;
-
-use serde_jsonrc::{Number, Value};
+use serde_jsonrc::{json, Number, Value};
 
 #[test]
 fn number() {
diff --git a/tests/map.rs b/tests/map.rs
new file mode 100644
index 0000000..d69c183
--- /dev/null
+++ b/tests/map.rs
@@ -0,0 +1,36 @@
+use serde_jsonrc::{from_str, Map, Value};
+
+#[test]
+fn test_preserve_order() {
+    // Sorted order
+    #[cfg(not(feature = "preserve_order"))]
+    const EXPECTED: &[&str] = &["a", "b", "c"];
+
+    // Insertion order
+    #[cfg(feature = "preserve_order")]
+    const EXPECTED: &[&str] = &["b", "a", "c"];
+
+    let v: Value = from_str(r#"{"b":null,"a":null,"c":null}"#).unwrap();
+    let keys: Vec<_> = v.as_object().unwrap().keys().collect();
+    assert_eq!(keys, EXPECTED);
+}
+
+#[test]
+fn test_append() {
+    // Sorted order
+    #[cfg(not(feature = "preserve_order"))]
+    const EXPECTED: &[&str] = &["a", "b", "c"];
+
+    // Insertion order
+    #[cfg(feature = "preserve_order")]
+    const EXPECTED: &[&str] = &["b", "a", "c"];
+
+    let mut v: Value = from_str(r#"{"b":null,"a":null,"c":null}"#).unwrap();
+    let val = v.as_object_mut().unwrap();
+    let mut m = Map::new();
+    m.append(val);
+    let keys: Vec<_> = m.keys().collect();
+
+    assert_eq!(keys, EXPECTED);
+    assert!(val.is_empty());
+}
diff --git a/tests/preserve_order.rs b/tests/preserve_order.rs
deleted file mode 100644
index c4d39c8..0000000
--- a/tests/preserve_order.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-extern crate serde_jsonrc;
-
-use serde_jsonrc::{from_str, Value};
-
-#[test]
-fn test_map_order() {
-    // Sorted order
-    #[cfg(not(feature = "preserve_order"))]
-    const EXPECTED: &[&str] = &["a", "b", "c"];
-
-    // Insertion order
-    #[cfg(feature = "preserve_order")]
-    const EXPECTED: &[&str] = &["b", "a", "c"];
-
-    let v: Value = from_str(r#"{"b":null,"a":null,"c":null}"#).unwrap();
-    let keys: Vec<_> = v.as_object().unwrap().keys().collect();
-    assert_eq!(keys, EXPECTED);
-}
diff --git a/tests/regression.rs b/tests/regression.rs
index eff29ff..34c67d2 100644
--- a/tests/regression.rs
+++ b/tests/regression.rs
@@ -1,6 +1,2 @@
-extern crate automod;
-extern crate serde;
-extern crate serde_derive;
-
 #[path = "regression/mod.rs"]
 mod regression;
diff --git a/tests/stream.rs b/tests/stream.rs
index 9638e48..7b614b5 100644
--- a/tests/stream.rs
+++ b/tests/stream.rs
@@ -1,14 +1,9 @@
 #![cfg(not(feature = "preserve_order"))]
 
-extern crate serde;
-
-#[macro_use]
-extern crate serde_jsonrc;
-
-use serde_jsonrc::{Deserializer, Value};
+use serde_jsonrc::{json, Deserializer, Value};
 
 // Rustfmt issue https://github.com/rust-lang-nursery/rustfmt/issues/2740
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 macro_rules! test_stream {
     ($data:expr, $ty:ty, |$stream:ident| $test:block) => {
         {
diff --git a/tests/test.rs b/tests/test.rs
index c9f9070..0009212 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,20 +1,20 @@
 #![cfg(not(feature = "preserve_order"))]
-#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, unreadable_literal))]
+#![allow(clippy::float_cmp, clippy::unreadable_literal)]
 #![cfg_attr(feature = "trace-macros", feature(trace_macros))]
 #[cfg(feature = "trace-macros")]
 trace_macros!(true);
 
 #[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-extern crate serde_bytes;
-#[macro_use]
-extern crate serde_jsonrc;
-
-#[macro_use]
 mod macros;
 
+use serde::de::{self, IgnoredAny, IntoDeserializer};
+use serde::ser::{self, Serializer};
+use serde::{Deserialize, Serialize};
+use serde_bytes::{ByteBuf, Bytes};
+use serde_jsonrc::{
+    from_reader, from_slice, from_str, from_value, json, to_string, to_string_pretty, to_value,
+    to_vec, to_writer, Deserializer, Number, Value,
+};
 use std::collections::BTreeMap;
 use std::fmt::{self, Debug};
 use std::io;
@@ -26,16 +26,6 @@
 use std::{i16, i32, i64, i8};
 use std::{u16, u32, u64, u8};
 
-use serde::de::{self, Deserialize, IgnoredAny, IntoDeserializer};
-use serde::ser::{self, Serialize, Serializer};
-
-use serde_bytes::{ByteBuf, Bytes};
-
-use serde_jsonrc::{
-    from_reader, from_slice, from_str, from_value, to_string, to_string_pretty, to_value, to_vec,
-    to_writer, Deserializer, Number, Value,
-};
-
 macro_rules! treemap {
     () => {
         BTreeMap::new()
@@ -2000,7 +1990,7 @@
 
 #[test]
 // Clippy false positive: https://github.com/Manishearth/rust-clippy/issues/292
-#[cfg_attr(feature = "cargo-clippy", allow(needless_lifetimes))]
+#[allow(clippy::needless_lifetimes)]
 fn test_into_io_error() {
     fn io_error<'de, T: Deserialize<'de> + Debug>(j: &'static str) -> io::Error {
         from_str::<T>(j).unwrap_err().into()