--- a/src/combinators.rs	Sun Jun 02 10:44:18 2019 +0000
+++ b/src/combinators.rs	Sun Jun 02 13:47:52 2019 +0200
@@ -1,3 +1,5 @@
+use std::ops::Shr;
+
 use crate::parser::{ParseError, ParseResult, Parser};
 use crate::state::ParseState;
 
@@ -101,11 +103,6 @@
 /// Individual parsers need to have result types implementing Default.
 pub struct Sequence<T>(T);
 
-macro_rules! sequence {
-    ($($p:expr),+) => { Sequence::new(($($p),*)) };
-    ($p:expr) => { $p };
-}
-
 impl<T> Sequence<T> {
     pub fn new(tuple: T) -> Sequence<T> {
         Sequence(tuple)
@@ -264,13 +261,19 @@
 
 impl<P: Parser> Repeat<P> {
     pub fn new(p: P, r: RepeatSpec) -> Repeat<P> {
-        Repeat { inner: p, repeat: r }
+        Repeat {
+            inner: p,
+            repeat: r,
+        }
     }
 }
 
-impl<R, P: Parser<Result=R>> Parser for Repeat<P> {
+impl<R, P: Parser<Result = R>> Parser for Repeat<P> {
     type Result = Vec<R>;
-    fn parse(&mut self, st: &mut ParseState<impl Iterator<Item=char>>) -> ParseResult<Self::Result> {
+    fn parse(
+        &mut self,
+        st: &mut ParseState<impl Iterator<Item = char>>,
+    ) -> ParseResult<Self::Result> {
         let (min, max) = match self.repeat {
             RepeatSpec::Any => (0, std::usize::MAX),
             RepeatSpec::Min(min) => (min as usize, std::usize::MAX),
@@ -354,14 +357,19 @@
     fn test_partial_sequence() {
         let mut p = PartialSequence::new((StringParser::new("a"), StringParser::new("c"), Int));
         let mut ps = ParseState::new("acde");
-        assert_eq!(Ok((Some("a".to_string()), Some("c".to_string()), None)), p.parse(&mut ps));
+        assert_eq!(
+            Ok((Some("a".to_string()), Some("c".to_string()), None)),
+            p.parse(&mut ps)
+        );
 
-        let mut p = PartialSequence::new(
-            (Sequence::new((Int, StringParser::new(" "), Int)),
-            StringParser::new("x")));
+        let mut p = PartialSequence::new((
+            Sequence::new((Int, StringParser::new(" "), Int)),
+            StringParser::new("x"),
+        ));
         let mut ps = ParseState::new("12 -12 nothing else");
-        assert_eq!(Ok((
-                    Some((12, " ".to_string(), -12)),
-                    None)), p.parse(&mut ps));
+        assert_eq!(
+            Ok((Some((12, " ".to_string(), -12)), None)),
+            p.parse(&mut ps)
+        );
     }
 }

--- a/src/primitives.rs	Sun Jun 02 10:44:18 2019 +0000
+++ b/src/primitives.rs	Sun Jun 02 13:47:52 2019 +0200
@@ -89,21 +89,25 @@
 
 impl Parser for OneOf {
     type Result = char;
-    fn parse(&mut self, st: &mut ParseState<impl Iterator<Item = char>>) -> ParseResult<Self::Result> {
+    fn parse(
+        &mut self,
+        st: &mut ParseState<impl Iterator<Item = char>>,
+    ) -> ParseResult<Self::Result> {
         match st.peek() {
-            Some(c) if self.0.contains(&c) => { st.next(); Ok(c) },
+            Some(c) if self.0.contains(&c) => {
+                st.next();
+                Ok(c)
+            }
             _ => Err(ParseError::Fail("char not matched", st.index())),
         }
     }
 }
 
 /// A parser that parses a string consisting of characters `chars`.
-fn string_of<S: AsRef<str>>(chars: S, rp: RepeatSpec) -> impl Parser<Result=String> {
+fn string_of<S: AsRef<str>>(chars: S, rp: RepeatSpec) -> impl Parser<Result = String> {
     let oo = OneOf::new(chars);
     let rp = Repeat::new(oo, rp);
-    let make_string = |charvec: Vec<char>| {
-        Ok(String::from_iter(charvec.into_iter()))
-    };
+    let make_string = |charvec: Vec<char>| Ok(String::from_iter(charvec.into_iter()));
     Transform::new(rp, make_string)
 }