diff --git a/Cargo.toml b/Cargo.toml
index 82f1236..68dc203 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ heapless = "0.8.0"
 
 [dependencies.nom]
 default-features = false
-version = "7.1.3"
+version = "8.0.0"
 
 [features]
 default = ["std"]
diff --git a/src/parsers.rs b/src/parsers.rs
index 76aef6a..197fff9 100644
--- a/src/parsers.rs
+++ b/src/parsers.rs
@@ -8,70 +8,76 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::{digit0, digit1};
 use nom::combinator::{map, map_res, opt, value};
-use nom::sequence::{delimited, preceded, tuple};
+use nom::sequence::{delimited, preceded};
 use nom::IResult;
+use nom::Parser;
 
 macro_rules! tag_parser {
     ($sig:ident, $tag:expr, $ret:expr) => {
         fn $sig(input: &str) -> IResult<&str, AnsiSequence> {
-            value($ret, tag($tag))(input)
+            value($ret, tag($tag)).parse(input)
         }
     };
 }
 
 fn parse_u32(input: &str) -> IResult<&str, u32> {
-    map_res(digit1, |s: &str| s.parse::<u32>())(input)
+    map_res(digit1, |s: &str| s.parse::<u32>()).parse(input)
 }
 
 fn parse_u8(input: &str) -> IResult<&str, u8> {
-    map_res(digit1, |s: &str| s.parse::<u8>())(input)
+    map_res(digit1, |s: &str| s.parse::<u8>()).parse(input)
 }
 
 // TODO kind of ugly, would prefer to pass in the default so we could use it for
 // all escapes with defaults (not just those that default to 1).
 fn parse_def_cursor_int(input: &str) -> IResult<&str, u32> {
-    map(digit0, |s: &str| s.parse::<u32>().unwrap_or(1))(input)
+    map(digit0, |s: &str| s.parse::<u32>().unwrap_or(1)).parse(input)
 }
 
 fn cursor_pos(input: &str) -> IResult<&str, AnsiSequence> {
     map(
-        tuple((
+        (
             tag("["),
             parse_def_cursor_int,
             opt(tag(";")),
             parse_def_cursor_int,
             alt((tag("H"), tag("f"))),
-        )),
+        ),
         |(_, x, _, y, _)| AnsiSequence::CursorPos(x, y),
-    )(input)
+    )
+    .parse(input)
 }
 
 fn escape(input: &str) -> IResult<&str, AnsiSequence> {
-    value(AnsiSequence::Escape, tag("\u{1b}"))(input)
+    value(AnsiSequence::Escape, tag("\u{1b}")).parse(input)
 }
 
 fn cursor_up(input: &str) -> IResult<&str, AnsiSequence> {
     map(delimited(tag("["), parse_def_cursor_int, tag("A")), |am| {
         AnsiSequence::CursorUp(am)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn cursor_down(input: &str) -> IResult<&str, AnsiSequence> {
     map(delimited(tag("["), parse_def_cursor_int, tag("B")), |am| {
         AnsiSequence::CursorDown(am)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn cursor_forward(input: &str) -> IResult<&str, AnsiSequence> {
     map(delimited(tag("["), parse_def_cursor_int, tag("C")), |am| {
         AnsiSequence::CursorForward(am)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn cursor_backward(input: &str) -> IResult<&str, AnsiSequence> {
     map(delimited(tag("["), parse_def_cursor_int, tag("D")), |am| {
         AnsiSequence::CursorBackward(am)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn graphics_mode1(input: &str) -> IResult<&str, AnsiSequence> {
@@ -79,23 +85,25 @@ fn graphics_mode1(input: &str) -> IResult<&str, AnsiSequence> {
         let mode =
             Vec::from_slice(&[val]).expect("Vec::from_slice should allocate sufficient size");
         AnsiSequence::SetGraphicsMode(mode)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn graphics_mode2(input: &str) -> IResult<&str, AnsiSequence> {
     map(
-        tuple((tag("["), parse_u8, tag(";"), parse_u8, tag("m"))),
+        (tag("["), parse_u8, tag(";"), parse_u8, tag("m")),
         |(_, val1, _, val2, _)| {
             let mode = Vec::from_slice(&[val1, val2])
                 .expect("Vec::from_slice should allocate sufficient size");
             AnsiSequence::SetGraphicsMode(mode)
         },
-    )(input)
+    )
+    .parse(input)
 }
 
 fn graphics_mode3(input: &str) -> IResult<&str, AnsiSequence> {
     map(
-        tuple((
+        (
             tag("["),
             parse_u8,
             tag(";"),
@@ -103,22 +111,23 @@ fn graphics_mode3(input: &str) -> IResult<&str, AnsiSequence> {
             tag(";"),
             parse_u8,
             tag("m"),
-        )),
+        ),
         |(_, val1, _, val2, _, val3, _)| {
             let mode = Vec::from_slice(&[val1, val2, val3])
                 .expect("Vec::from_slice should allocate sufficient size");
             AnsiSequence::SetGraphicsMode(mode)
         },
-    )(input)
+    )
+    .parse(input)
 }
 
 fn graphics_mode4(input: &str) -> IResult<&str, AnsiSequence> {
-    value(AnsiSequence::SetGraphicsMode(Vec::new()), tag("[m"))(input)
+    value(AnsiSequence::SetGraphicsMode(Vec::new()), tag("[m")).parse(input)
 }
 
 fn graphics_mode5(input: &str) -> IResult<&str, AnsiSequence> {
     map(
-        tuple((
+        (
             tag("["),
             parse_u8,
             tag(";"),
@@ -130,13 +139,14 @@ fn graphics_mode5(input: &str) -> IResult<&str, AnsiSequence> {
             tag(";"),
             parse_u8,
             tag("m"),
-        )),
+        ),
         |(_, val1, _, val2, _, val3, _, val4, _, val5, _)| {
             let mode = Vec::from_slice(&[val1, val2, val3, val4, val5])
                 .expect("Vec::from_slice should allocate sufficient size");
             AnsiSequence::SetGraphicsMode(mode)
         },
-    )(input)
+    )
+    .parse(input)
 }
 
 fn graphics_mode(input: &str) -> IResult<&str, AnsiSequence> {
@@ -146,26 +156,30 @@ fn graphics_mode(input: &str) -> IResult<&str, AnsiSequence> {
         graphics_mode3,
         graphics_mode4,
         graphics_mode5,
-    ))(input)
+    ))
+    .parse(input)
 }
 
 fn set_mode(input: &str) -> IResult<&str, AnsiSequence> {
     map(delimited(tag("[="), parse_u8, tag("h")), |val| {
         AnsiSequence::SetMode(val)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn reset_mode(input: &str) -> IResult<&str, AnsiSequence> {
     map(delimited(tag("[="), parse_u8, tag("l")), |val| {
         AnsiSequence::ResetMode(val)
-    })(input)
+    })
+    .parse(input)
 }
 
 fn set_top_and_bottom(input: &str) -> IResult<&str, AnsiSequence> {
     map(
-        tuple((tag("["), parse_u32, tag(";"), parse_u32, tag("r"))),
+        (tag("["), parse_u32, tag(";"), parse_u32, tag("r")),
         |(_, x, _, y, _)| AnsiSequence::SetTopAndBottom(x, y),
-    )(input)
+    )
+    .parse(input)
 }
 
 tag_parser!(cursor_save, "[s", AnsiSequence::CursorSave);
@@ -267,9 +281,10 @@ fn combined(input: &str) -> IResult<&str, AnsiSequence> {
         set_g1_graph,
         set_single_shift2,
         set_single_shift3,
-    ))(input)
+    ))
+    .parse(input)
 }
 
 pub fn parse_escape(input: &str) -> IResult<&str, AnsiSequence> {
-    preceded(tag("\u{1b}"), combined)(input)
+    preceded(tag("\u{1b}"), combined).parse(input)
 }