diff --git a/Cargo.toml b/Cargo.toml
index 4c62071..b671ecf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ categories = ["parsing"]
 regex = "1.0"
 
 [dependencies.nom]
-version = "7.0.0"
+version = "8.0.0"
 default-features = false
 
 [features]
diff --git a/src/lib.rs b/src/lib.rs
index cc4a298..f2a064d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -33,8 +33,8 @@ pub mod str {
     use nom::error::{ErrorKind, ParseError};
     #[cfg(feature = "alloc")]
     use nom::lib::std::vec::Vec;
+    use nom::Input;
     use nom::{Err, IResult};
-    use nom::{InputLength, Slice};
     use regex::Regex;
 
     /// Compares the input with a regular expression and returns the
@@ -60,7 +60,7 @@ pub mod str {
     {
         move |i| {
             if re.is_match(i) {
-                Ok((i.slice(i.input_len()..), i))
+                Ok((i.take_from(i.input_len()), i))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpMatch)))
             }
@@ -91,14 +91,14 @@ pub mod str {
         move |i| {
             let v: Vec<_> = re
                 .find_iter(i)
-                .map(|m| i.slice(m.start()..m.end()))
+                .map(|m| i.take_from(m.start()).take(m.end() - m.start()))
                 .collect();
             if !v.is_empty() {
                 let offset = {
                     let end = v.last().unwrap();
                     end.as_ptr() as usize + end.len() - i.as_ptr() as usize
                 };
-                Ok((i.slice(offset..), v))
+                Ok((i.take_from(offset), v))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpMatches)))
             }
@@ -128,7 +128,10 @@ pub mod str {
     {
         move |i| {
             if let Some(m) = re.find(i) {
-                Ok((i.slice(m.end()..), i.slice(m.start()..m.end())))
+                Ok((
+                    i.take_from(m.end()),
+                    i.take_from(m.start()).take(m.end() - m.start()),
+                ))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpFind)))
             }
@@ -161,15 +164,14 @@ pub mod str {
             if let Some(c) = re.captures(i) {
                 let v: Vec<_> = c
                     .iter()
-                    .filter(|el| el.is_some())
-                    .map(|el| el.unwrap())
-                    .map(|m| i.slice(m.start()..m.end()))
+                    .flatten()
+                    .map(|m| i.take_from(m.start()).take(m.end() - m.start()))
                     .collect();
                 let offset = {
                     let end = v.last().unwrap();
                     end.as_ptr() as usize + end.len() - i.as_ptr() as usize
                 };
-                Ok((i.slice(offset..), v))
+                Ok((i.take_from(offset), v))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpCapture)))
             }
@@ -205,9 +207,8 @@ pub mod str {
                 .captures_iter(i)
                 .map(|c| {
                     c.iter()
-                        .filter(|el| el.is_some())
-                        .map(|el| el.unwrap())
-                        .map(|m| i.slice(m.start()..m.end()))
+                        .flatten()
+                        .map(|m| i.take_from(m.start()).take(m.end() - m.start()))
                         .collect()
                 })
                 .collect();
@@ -216,7 +217,7 @@ pub mod str {
                     let end = v.last().unwrap().last().unwrap();
                     end.as_ptr() as usize + end.len() - i.as_ptr() as usize
                 };
-                Ok((i.slice(offset..), v))
+                Ok((i.take_from(offset), v))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpCapture)))
             }
@@ -244,7 +245,7 @@ pub mod str {
             assert_parse!(rm("2015-09-07"), Ok(("", "2015-09-07")));
             assert_eq!(
                 rm("blah"),
-                Err(Err::Error((&"blah"[..], ErrorKind::RegexpMatch)))
+                Err(Err::Error(("blah", ErrorKind::RegexpMatch)))
             );
             assert_eq!(rm("2015-09-07blah"), Ok(("", "2015-09-07blah")));
         }
@@ -254,10 +255,7 @@ pub mod str {
             let re = Regex::new(r"^\d{4}-\d{2}-\d{2}").unwrap();
             let rm = re_find(re);
             assert_parse!(rm("2015-09-07"), Ok(("", "2015-09-07")));
-            assert_eq!(
-                rm("blah"),
-                Err(Err::Error((&"blah"[..], ErrorKind::RegexpFind)))
-            );
+            assert_eq!(rm("blah"), Err(Err::Error(("blah", ErrorKind::RegexpFind))));
             assert_eq!(rm("2015-09-07blah"), Ok(("blah", "2015-09-07")));
         }
 
@@ -269,7 +267,7 @@ pub mod str {
             assert_parse!(rm("2015-09-07"), Ok(("", vec!["2015-09-07"])));
             assert_eq!(
                 rm("blah"),
-                Err(Err::Error((&"blah"[..], ErrorKind::RegexpMatches)))
+                Err(Err::Error(("blah", ErrorKind::RegexpMatches)))
             );
             assert_eq!(
                 rm("aaa2015-09-07blah2015-09-09pouet"),
@@ -313,7 +311,7 @@ pub mod str {
             );
             assert_eq!(
                 rm("blah"),
-                Err(Err::Error((&"blah"[..], ErrorKind::RegexpCapture)))
+                Err(Err::Error(("blah", ErrorKind::RegexpCapture)))
             );
             assert_eq!(
                 rm("hello nom 0.3.11 world regex 0.1.41 aaa"),
@@ -334,8 +332,8 @@ pub mod bytes {
     use nom::error::{ErrorKind, ParseError};
     #[cfg(feature = "alloc")]
     use nom::lib::std::vec::Vec;
+    use nom::Input;
     use nom::{Err, IResult};
-    use nom::{InputLength, Slice};
     use regex::bytes::Regex;
 
     /// Compares the input with a regular expression and returns the
@@ -361,7 +359,7 @@ pub mod bytes {
     {
         move |i| {
             if re.is_match(i) {
-                Ok((i.slice(i.input_len()..), i))
+                Ok((i.take_from(i.input_len()), i))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpMatch)))
             }
@@ -392,14 +390,14 @@ pub mod bytes {
         move |i| {
             let v: Vec<_> = re
                 .find_iter(i)
-                .map(|m| i.slice(m.start()..m.end()))
+                .map(|m| i.take_from(m.start()).take(m.end() - m.start()))
                 .collect();
             if !v.is_empty() {
                 let offset = {
                     let end = v.last().unwrap();
                     end.as_ptr() as usize + end.len() - i.as_ptr() as usize
                 };
-                Ok((i.slice(offset..), v))
+                Ok((i.take_from(offset), v))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpMatches)))
             }
@@ -429,7 +427,10 @@ pub mod bytes {
     {
         move |i| {
             if let Some(m) = re.find(i) {
-                Ok((i.slice(m.end()..), i.slice(m.start()..m.end())))
+                Ok((
+                    i.take_from(m.end()),
+                    i.take_from(m.start()).take(m.end() - m.start()),
+                ))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpFind)))
             }
@@ -462,15 +463,14 @@ pub mod bytes {
             if let Some(c) = re.captures(i) {
                 let v: Vec<_> = c
                     .iter()
-                    .filter(|el| el.is_some())
-                    .map(|el| el.unwrap())
-                    .map(|m| i.slice(m.start()..m.end()))
+                    .flatten()
+                    .map(|m| i.take_from(m.start()).take(m.end() - m.start()))
                     .collect();
                 let offset = {
                     let end = v.last().unwrap();
                     end.as_ptr() as usize + end.len() - i.as_ptr() as usize
                 };
-                Ok((i.slice(offset..), v))
+                Ok((i.take_from(offset), v))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpCapture)))
             }
@@ -506,9 +506,8 @@ pub mod bytes {
                 .captures_iter(i)
                 .map(|c| {
                     c.iter()
-                        .filter(|el| el.is_some())
-                        .map(|el| el.unwrap())
-                        .map(|m| i.slice(m.start()..m.end()))
+                        .flatten()
+                        .map(|m| i.take_from(m.start()).take(m.end() - m.start()))
                         .collect()
                 })
                 .collect();
@@ -517,7 +516,7 @@ pub mod bytes {
                     let end = v.last().unwrap().last().unwrap();
                     end.as_ptr() as usize + end.len() - i.as_ptr() as usize
                 };
-                Ok((i.slice(offset..), v))
+                Ok((i.take_from(offset), v))
             } else {
                 Err(Err::Error(E::from_error_kind(i, ErrorKind::RegexpCapture)))
             }