--- a/formats/src/th06/ecl.rs
+++ b/formats/src/th06/ecl.rs
@@ -2,8 +2,8 @@
 
 use nom::{
     IResult,
+    Parser,
     number::complete::{le_u8, le_u16, le_u32, le_i16, le_i32, le_f32},
-    sequence::tuple,
     multi::{count, many0},
     error::ErrorKind,
     Err,
@@ -329,12 +329,12 @@
 
 fn parse_sub_instruction(input: &[u8]) -> IResult<&[u8], CallSub> {
     let i = &input[..];
-    let (i, (time, opcode)) = tuple((le_i32, le_u16))(i)?;
+    let (i, (time, opcode)) = (le_i32, le_u16).parse(i)?;
     if time == -1 || opcode == 0xffff {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
 
-    let (i, (size, rank_mask, param_mask)) = tuple((le_u16, le_u16, le_u16))(i)?;
+    let (i, (size, rank_mask, param_mask)) = (le_u16, le_u16, le_u16).parse(i)?;
     let rank_mask = Rank::from_bits(rank_mask).unwrap();
     let (i, instr) = parse_sub_instruction_args(i, opcode)?;
     assert_eq!(input.len() - i.len(), size as usize);
@@ -343,19 +343,19 @@
 }
 
 fn parse_sub(i: &[u8]) -> IResult<&[u8], Sub> {
-    let (i, instructions) = many0(parse_sub_instruction)(i)?;
+    let (i, instructions) = many0(parse_sub_instruction).parse(i)?;
     let sub = Sub { instructions };
     Ok((i, sub))
 }
 
 fn parse_main_instruction(input: &[u8]) -> IResult<&[u8], CallMain> {
     let i = &input[..];
-    let (i, (time, sub)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (time, sub)) = (le_u16, le_u16).parse(i)?;
     if time == 0xffff && sub == 4 {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
 
-    let (i, (opcode, size)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (opcode, size)) = (le_u16, le_u16).parse(i)?;
     let size = size as usize;
     let (i, instr) = parse_main_instruction_args(i, opcode)?;
     assert_eq!(input.len() - i.len(), size as usize);
@@ -364,7 +364,7 @@
 }
 
 fn parse_main(i: &[u8]) -> IResult<&[u8], Main> {
-    let (i, instructions) = many0(parse_main_instruction)(i)?;
+    let (i, instructions) = many0(parse_main_instruction).parse(i)?;
     let main = Main { instructions };
     Ok((i, main))
 }
@@ -372,7 +372,7 @@
 fn parse_ecl(input: &[u8]) -> IResult<&[u8], Ecl> {
     let i = input;
 
-    let (i, (sub_count, main_count)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (sub_count, main_count)) = (le_u16, le_u16).parse(i)?;
     let sub_count = sub_count as usize;
 
     if main_count != 0 {
@@ -380,10 +380,10 @@
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
 
-    let (_, (main_offsets, sub_offsets)) = tuple((
+    let (_, (main_offsets, sub_offsets)) = (
         count(le_u32, 3),
         count(le_u32, sub_count),
-    ))(i)?;
+    ).parse(i)?;
 
     // Read all subs.
     let mut subs = Vec::new();