mod.rs

            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        let p2 = Char {c: 'x'};

        match parser!(p *> p2 *> 'k').parse("cxk") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!('c' *> ('x' *> 'k') *> 'r').parse("cxkr") {
            Ok(c) => {
                assert_eq!(c, 'r');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!(('c' *> 'x') *> 'k' *> 'r').parse("cxkr") {
            Ok(c) => {
                assert_eq!(c, 'r');
            },
            Err(e) => panic!("{}", e)
        }


        match parser!(('c' *> 'x') *> ('k' *> 'r') *> 'm').parse("cxkrm") {
            Ok(c) => {
                assert_eq!(c, 'm');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!(('c' *> 'x') *> ('k' *> 'r') *> 'm').parse("cxkrm") {
            Ok(c) => {
                assert_eq!(c, 'm');
            },
            Err(e) => panic!("{}", e)
        }

        // Not fully covered, but essentially right associativity with idents

        let p = Char {c:'k'};
        match parser!(('c' *> 'x') *> p *> 'm').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'm');
            },
            Err(e) => panic!("{}", e)
        }

        Ok(())
    }

    #[test]
    fn test_right_r_combine() -> Result<(), String> {

        let p = Char {c: 'k'};
        match parser!('c' *> 'x' <|> p).parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'x');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!(p *> 'x' <|> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'x');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'x'};
        match parser!('c' *> p <|> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'x');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        let p2 = Char {c: 'x'};
        match parser!(p *> p2 <|> 'k').parse("km") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }


        match parser!(('c' *> 'k') *> ('x' *> 'b') <|> 'k').parse("k") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'k'};
        match parser!('c' *> 'x' <~> p).parse("cxkm") {
            Ok((c, c2)) => {
                assert_eq!(c, 'x');
                assert_eq!(c2, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!(p *> 'x' <~> 'k').parse("cxkm") {
            Ok((c, c2)) => {
                assert_eq!(c, 'x');
                assert_eq!(c2, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'x'};
        match parser!('c' *> p <~> 'k').parse("cxkm") {
            Ok((c, c2)) => {
                assert_eq!(c, 'x');
                assert_eq!(c2, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        let p2 = Char {c: 'x'};
        match parser!(p *> p2 <~> 'k').parse("cxkm") {
            Ok((c, c2)) => {
                assert_eq!(c, 'x');
                assert_eq!(c2, 'k');
            },
            Err(e) => panic!("{}", e)
        }


        match parser!(('c' *> 'k') *> ('x' *> 'b') <~> 'k').parse("ckxbk") {
            Ok((c, c2)) => {
                assert_eq!(c, 'b');
                assert_eq!(c2, 'k');
            },
            Err(e) => panic!("{}", e)
        }
        Ok(())
    }

    #[test]
    fn test_combine_right_r() -> Result<(), String> {

        let p = Char {c: 'k'};
        match parser!('c' <|> 'x' *> p).parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'c');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!(p <|> 'x' *> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'c');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'x'};
        match parser!('c' <|> p *> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'c');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        let p2 = Char {c: 'x'};
        match parser!(p <|> p2 *> 'k').parse("xk") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!(('c' *> 'k') <|> ('x' *> 'b') *> 'k').parse("xbk") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'k'};
        match parser!('c' <~> 'x' *> p).parse("cxkm") {
            Ok(c ) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!(p <~> 'x' *> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'x'};
        match parser!('c' <~> p *> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        let p2 = Char {c: 'x'};
        match parser!(p <~> p2 *> 'k').parse("cxkm") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }


        match parser!(('c' *> 'k') <~> ('x' *> 'b') *> 'k').parse("ckxbk") {
            Ok(c) => {
                assert_eq!(c, 'k');
            },
            Err(e) => panic!("{}", e)
        }
        Ok(())
    }


    #[test]
    fn test_left() -> Result<(), String>{
        let p = Char {c: 'c'};
        let p2 = Char {c: 'k'};
        let p3 = Char {c: 'l'};

        match parser!('c'<*'x').parse("cx") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        match parser!(p<*p2).parse("ck") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        match parser!('c' <* 'm').parse("cl") {
            Ok(_) => panic!("Didnt fail at m"),
            Err(_e) => ()
        }

        match parser!(('c' <* ('a' <* 'r'))).parse("car") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        match parser!(p3<*'x').parse("lx") {
            Ok(c) => {
                assert_eq!(c, 'l');
                Ok(())
            },
            Err(e) => panic!("{}", e)
        }        
    }


    #[test]
    fn test_right() -> Result<(), String>{
        let p = Char {c: 'c'};
        let p2 = Char {c: 'k'};
        let p3 = Char {c: 'l'};

        match parser!('c'*>'x').parse("cx") {
            Ok(c) => assert_eq!(c, 'x'),
            Err(e) => panic!("{}", e)
        }

        match parser!(p*>p2).parse("ck") {
            Ok(c) => assert_eq!(c, 'k'),
            Err(e) => panic!("{}", e)
        }

        match parser!('c' *> 'm').parse("cl") {
            Ok(_) => panic!("Didnt fail at m"),
            Err(_e) => ()
        }

        let p = Char {c: 'a'};
        match parser!('c' *> p *> 'r').parse("car") {
            Ok(c) => assert_eq!(c, 'r'),
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!((p *> 'a' *> 'r')).parse("car") {
            Ok(c) => assert_eq!(c, 'r'),
            Err(e) => panic!("{}", e)
        }

        match parser!(p3*>'x').parse("lx") {
            Ok(c) => {
                assert_eq!(c, 'x');
                Ok(())
            },
            Err(e) => panic!("{}", e)
        }
        
    }

    #[test]
    fn test_recursive_extra() -> Result<(), String> {

        match parser!(('a' *> 'b') <|> 'c').parse("ab") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        match parser!(('a' *> 'b') <|> 'c').parse("cb") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!(('a' *> 'b') <|> p).parse("ab") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'c'};
        match parser!(p *> 'b' <|> 'k').parse("cb") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        match parser!(('a' <|> 'b') <|> 'c').parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        match parser!(('a' <|> 'b') <|> 'c').parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        match parser!('a' <|> 'b' <|> 'c').parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        match parser!('a' <|> 'b' <|> ('c' <|> 'c')).parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'a'};
        match parser!(p <|> 'b' <|> ('c' <|> 'c') <|> 'l').parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'b'};
        match parser!('a' <|> p <|> ('c' <|> 'c')).parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        let p1 = Char {c: 'a'};
        let p2 = Char {c: 'b'};
        match parser!(p1 <|> p2 <|> ('c' <|> 'c')).parse("b") {
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }

        match parser!(('a' <~> 'b') <|> ('c' <~> 'c')).parse("cc") {
            Ok((c1, c2)) => {
                assert_eq!(c1, 'c');
                assert_eq!(c2, 'c');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!('a' <~> 'b' <|> ('c' <~> 'c')).parse("cc") {
            Ok((c1, c2)) => {
                assert_eq!(c1, 'c');
                assert_eq!(c2, 'c');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!(('a' *> 'b') *> 'c').parse("abc") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        let p = Char {c: 'a'};
        match parser!(p *> ('b' *> 'c')).parse("abc") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        match parser!(('a' <~> 'b') <~> 'c').parse("abc") {
            Ok(((a, b), c)) => {
                assert_eq!(a, 'a');
                assert_eq!(b, 'b');
                assert_eq!(c, 'c');
            },
            Err(e) => panic!("{}", e)
        }

        match parser!('a' <~> ('b' <~> 'c')).parse("abc") {
            Ok((a, (b, c))) => {
                assert_eq!(a, 'a');
                assert_eq!(b, 'b');
                assert_eq!(c, 'c');
            },
            Err(e) => panic!("{}", e)
        }
        Ok(())
    }


    #[test]
    fn test_hello_world_brackets() -> Result<(), String> {
        let p = parser!(('h' *> (((('e' *> 'l') *> 'l') *> 'o') <|> 'i')) *> ((((' '*> ('w' *> 'o')) *> 'r') *> 'l') *>'d'));
        match p.parse("hello world") {
            Ok(_c) => (),
            Err(e) => panic!("{}", e) 
        }

        match p.parse("hi world") {
            Ok(_c) => (),
            Err(e) => panic!("{}", e) 
        }
        
        Ok(())
    }

    #[test]
    fn test_hello_world_non_brackets() -> Result<(), String> {

        let p = parser!('h' *> ('e' *> 'l' *> 'l' *> 'o' <|> 'i') *> ' ' *>'w' *> 'o' *> 'r' *> 'l' *> 'd');
        
        match p.parse("hello world") {
            Ok(_c) => (),
            Err(e) => panic!("{}", e) 
        }

        match p.parse("hi world") {
            Ok(_c) => (),
            Err(e) => panic!("{}", e) 
        }

        Ok(())
    }

    #[test]
    fn test_try() -> Result<(), String>{
        let p = Char {c: 'c'};
        match parser!(try(p)).parse("cb") {
            Ok(c) => assert_eq!(c, 'c'),
            Err(e) => panic!("{}", e)
        }

        match parser!(try 'c' *> try ('d' <|> 'c')).parse("cd") {
            Ok(c) => assert_eq!(c, 'd'),
            Err(e) => panic!("{}", e)
        }

        match parser!(try 'c').parse("cb") {
            Ok(c) => {
                assert_eq!(c, 'c');
                Ok(())
            },
            Err(e) => panic!("{}", e)
        }
    }

    #[test]
    fn test_map() -> Result<(), String>{
        let f = |_c: char| 'b';
        match parser!(f <#> 'c').parse("c"){
            Ok(c) => assert_eq!(c, 'b'),
            Err(e) => panic!("{}", e)
        }
        let p = Char {c: 'c'};
        match parser!((f <#> p)).parse("c"){
            Ok(c) => {
                assert_eq!(c, 'b');
                Ok(())
            },
            Err(e) => panic!("{}", e)
        }
    }

}