Update nom and iso8601 dependencies

6 files changed, 254 insertions, 229 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 38a1ec5..b13dc98 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,8 +13,8 @@ repository    = "https://git.beyermatthi.as/kairos"
 
 [dependencies]
 chrono = "0.4"
-nom = "3"
-iso8601 = "0.2"
+nom = "7"
+iso8601 = "0.6"
 thiserror = "1"
 
 filters = { version  = "0.4", optional = true }
diff --git a/src/error.rs b/src/error.rs
index 548dcc1..bb1aa80 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,7 +2,7 @@ use timetype::TimeType;
 
 use thiserror::Error;
 
-pub type Result<T> = ::std::result::Result<T, Error>;
+pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 #[derive(Debug, Clone, Eq, PartialEq, Error)]
 pub enum Error {
@@ -44,6 +44,6 @@ pub enum Error {
     UnknownParserError,
 
     #[error("Tokenizer error")]
-    NomError(#[from] nom::Err),
+    NomError(String),
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 6479ad2..b9e85c1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,7 +3,6 @@
 extern crate thiserror;
 extern crate chrono;
 
-#[macro_use]
 extern crate nom;
 extern crate iso8601;
 
diff --git a/src/parser/iterator.rs b/src/parser/iterator.rs
index fc4b6f9..21bf8d5 100644
--- a/src/parser/iterator.rs
+++ b/src/parser/iterator.rs
@@ -1,4 +1,9 @@
-use nom::whitespace::sp;
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::character::complete::{multispace0, multispace1};
+use nom::combinator::{complete, map, opt};
+use nom::IResult;
+use nom::sequence::tuple;
 
 use error::Result;
 use error::Error;
@@ -7,21 +12,18 @@ use timetype::IntoTimeType;
 use timetype;
 use iter;
 
-named!(pub iter_spec<Iterspec>, alt_complete!(
-    tag!("secondly") => { |_| Iterspec::Secondly } |
-    tag!("minutely") => { |_| Iterspec::Minutely } |
-    tag!("hourly")   => { |_| Iterspec::Hourly } |
-    tag!("daily")    => { |_| Iterspec::Daily } |
-    tag!("weekly")   => { |_| Iterspec::Weekly } |
-    tag!("monthly")  => { |_| Iterspec::Monthly } |
-    tag!("yearly")   => { |_| Iterspec::Yearly } |
-    do_parse!(
-        tag!("every") >>
-        number:integer >>
-        unit:unit_parser >>
-        (Iterspec::Every(number, unit))
-    )
-));
+pub fn iter_spec(i: &[u8]) -> IResult<&[u8], Iterspec> {
+    complete(alt((
+        map(tag("secondly"), |_| Iterspec::Secondly),
+        map(tag("minutely"), |_| Iterspec::Minutely),
+        map(tag("hourly"),   |_| Iterspec::Hourly),
+        map(tag("daily"),    |_| Iterspec::Daily),
+        map(tag("weekly"),   |_| Iterspec::Weekly),
+        map(tag("monthly"),  |_| Iterspec::Monthly),
+        map(tag("yearly"),   |_| Iterspec::Yearly),
+        map(tuple((tag("every"), integer, unit_parser)), |(_, number, unit)| Iterspec::Every(number, unit))
+    )))(i)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum Iterspec {
@@ -35,18 +37,18 @@ pub enum Iterspec {
     Every(i64, Unit),
 }
 
-named!(pub until_spec<UntilSpec>, alt_complete!(
-    do_parse!(
-        tag!("until") >> sp >>
-        exact: exact_date_parser >>
-        (UntilSpec::Exact(exact))
-    ) |
-    do_parse!(
-        num: integer >> sp >>
-        tag!("times") >>
-        (UntilSpec::Times(num))
-    )
-));
+pub fn until_spec(i: &[u8]) -> IResult<&[u8], UntilSpec> {
+    complete(alt((
+        map(
+            tuple((tag("until"), multispace1, exact_date_parser)),
+            |(_, _, exact)| UntilSpec::Exact(exact)
+        ),
+        map(
+            tuple((integer, multispace1, tag("times"))),
+            |(num, _, _)| UntilSpec::Times(num)
+        )
+    )))(i)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum UntilSpec {
@@ -54,12 +56,12 @@ pub enum UntilSpec {
     Times(i64)
 }
 
-named!(pub iterator<Iterator>, do_parse!(
-    opt!(sp) >> d: date         >>
-    opt!(sp) >> spec: iter_spec >>
-    opt!(sp) >> until: opt!(complete!(until_spec)) >>
-    (Iterator(d, spec, until))
-));
+pub fn iterator(i: &[u8]) -> IResult<&[u8], Iterator> {
+    map(
+        tuple((multispace0, date, multispace0, iter_spec, multispace0, opt(complete(until_spec)))),
+        |(_, d, _, spec, _, until)| { Iterator(d, spec, until) },
+    )(i)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Iterator(Date, Iterspec, Option<UntilSpec>);
@@ -149,7 +151,6 @@ impl<I> ::std::iter::Iterator for UserIterator<I>
 #[cfg(test)]
 mod tests {
     use std::iter::Iterator;
-    use nom::IResult;
     use super::*;
 
     use chrono::Timelike;
@@ -157,20 +158,20 @@ mod tests {
 
     #[test]
     fn test_iterspec() {
-        assert_eq!(iter_spec(&b"secondly"[..]), IResult::Done(&b""[..], Iterspec::Secondly));
-        assert_eq!(iter_spec(&b"minutely"[..]), IResult::Done(&b""[..], Iterspec::Minutely));
-        assert_eq!(iter_spec(&b"hourly"[..]), IResult::Done(&b""[..], Iterspec::Hourly));
-        assert_eq!(iter_spec(&b"daily"[..]), IResult::Done(&b""[..], Iterspec::Daily));
-        assert_eq!(iter_spec(&b"weekly"[..]), IResult::Done(&b""[..], Iterspec::Weekly));
-        assert_eq!(iter_spec(&b"monthly"[..]), IResult::Done(&b""[..], Iterspec::Monthly));
-        assert_eq!(iter_spec(&b"yearly"[..]), IResult::Done(&b""[..], Iterspec::Yearly));
-        assert_eq!(iter_spec(&b"every 5min"[..]), IResult::Done(&b""[..], Iterspec::Every(5, Unit::Minute)));
+        assert_eq!(iter_spec(&b"secondly"[..]), Ok((&b""[..], Iterspec::Secondly)));
+        assert_eq!(iter_spec(&b"minutely"[..]), Ok((&b""[..], Iterspec::Minutely)));
+        assert_eq!(iter_spec(&b"hourly"[..]), Ok((&b""[..], Iterspec::Hourly)));
+        assert_eq!(iter_spec(&b"daily"[..]), Ok((&b""[..], Iterspec::Daily)));
+        assert_eq!(iter_spec(&b"weekly"[..]), Ok((&b""[..], Iterspec::Weekly)));
+        assert_eq!(iter_spec(&b"monthly"[..]), Ok((&b""[..], Iterspec::Monthly)));
+        assert_eq!(iter_spec(&b"yearly"[..]), Ok((&b""[..], Iterspec::Yearly)));
+        assert_eq!(iter_spec(&b"every 5min"[..]), Ok((&b""[..], Iterspec::Every(5, Unit::Minute))));
     }
 
     #[test]
     fn test_iterator_1() {
         let res = iterator(&b"2017-01-01 hourly"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -194,7 +195,7 @@ mod tests {
     #[test]
     fn test_iterator_2() {
         let res = iterator(&b"2017-01-01 every 2mins"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -218,7 +219,7 @@ mod tests {
     #[test]
     fn test_iterator_3() {
         let res = iterator(&b"2017-01-01 daily"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -242,7 +243,7 @@ mod tests {
     #[test]
     fn test_iterator_4() {
         let res = iterator(&b"2017-01-01 weekly"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -266,7 +267,7 @@ mod tests {
     #[test]
     fn test_until_spec_1() {
         let res = until_spec(&b"until 2017-01-01T05:00:00"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
     }
@@ -274,7 +275,7 @@ mod tests {
     #[test]
     fn test_until_iterator_1() {
         let res = iterator(&b"2017-01-01 hourly until 2017-01-01T05:00:00"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -305,7 +306,7 @@ mod tests {
     #[test]
     fn test_until_iterator_2() {
         let res = iterator(&b"2017-01-01 every 2mins until 2017-01-01T00:10:00"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -335,7 +336,7 @@ mod tests {
     #[test]
     fn test_until_iterator_3() {
         let res = iterator(&b"2017-01-01 daily until 2017-01-05"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
@@ -365,7 +366,7 @@ mod tests {
     #[test]
     fn test_until_iterator_4() {
         let res = iterator(&b"2017-01-01 weekly until 2017-01-14"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 1338dc5..8d326ec 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -43,7 +43,8 @@
 //! Be warned!
 //!
 
-use nom::Needed;
+use nom::branch::alt;
+use nom::combinator::{complete, map};
 use nom::IResult;
 
 mod timetype;
@@ -53,27 +54,27 @@ use error::Result;
 use error::Error;
 use iter::Iter;
 use timetype::IntoTimeType;
-use parser::timetype::timetype;
-use parser::iterator::iterator;
+use parser::timetype::{timetype};
+use parser::iterator::{iterator};
 
 pub enum Parsed {
-    Iterator(Result<::parser::iterator::UserIterator<Iter>>),
+    Iterator(Result<iterator::UserIterator<Iter>>),
     TimeType(::timetype::TimeType)
 }
 
-named!(do_parse<Result<Parsed>>, alt_complete!(
-    do_parse!(it: iterator >> (Ok(Parsed::Iterator(it.into_user_iterator())))) |
-    do_parse!(tt: timetype >> (tt.into_timetype().map(Parsed::TimeType)))
-));
+fn do_parse(input: &[u8]) -> IResult<&[u8], Result<Parsed>> {
+    complete(alt((
+        map(iterator, |it| (Ok(Parsed::Iterator(it.into_user_iterator())))),
+        map(timetype, |tt| tt.into_timetype().map(Parsed::TimeType)),
+    )))(input)
+}
 
 pub fn parse(s: &str) -> Result<Parsed> {
     match do_parse(s.as_bytes()) {
-        IResult::Done(_, Ok(o))              => Ok(o),
-        IResult::Done(_, Err(e))             => Err(e),
-        IResult::Error(e)                    => Err(From::from(e)),
-        IResult::Incomplete(Needed::Unknown) => Err(Error::UnknownParserError),
-        IResult::Incomplete(Needed::Size(_)) => Err(Error::UnknownParserError),
-
+        Ok((_, Ok(o))) => Ok(o),
+        Ok((_, Err(e))) => Err(e),
+        Err(nom::Err::Error(e) | nom::Err::Failure(e)) => Err(Error::NomError(e.code.description().to_string())),
+        Err(nom::Err::Incomplete(_)) => Err(Error::UnknownParserError),
     }
 }
 
diff --git a/src/parser/timetype.rs b/src/parser/timetype.rs
index 7106d77..b957434 100644
--- a/src/parser/timetype.rs
+++ b/src/parser/timetype.rs
@@ -1,52 +1,69 @@
 use std::str;
-use std::str::FromStr;
 
-use nom::digit;
-use nom::whitespace::sp;
 use chrono::NaiveDate;
+use iso8601::parsers::{parse_date, parse_datetime};
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::character::complete::{digit1, multispace0, multispace1};
+use nom::combinator::{complete, map, map_opt, opt};
+use nom::IResult;
+use nom::sequence::{delimited, tuple};
 
-use timetype::IntoTimeType;
-use timetype;
-use error::Result;
 use error::Error;
+use error::Result;
+use timetype;
+use timetype::IntoTimeType;
 
-named!(pub integer<i64>, alt!(
-    map_res!(
-        map_res!(
-            ws!(digit),
-            str::from_utf8
-        ),
-        FromStr::from_str
-    )
-));
+pub fn integer(input: &[u8]) -> IResult<&[u8], i64> {
+    map_opt(
+        delimited(multispace0, digit1, multispace0),
+        |digit| str::from_utf8(digit).ok().and_then(|s| s.parse().ok()),
+    )(input)
+}
 
 // WARNING: Order is important here. Long tags first, shorter tags later
-named!(pub unit_parser<Unit>, alt_complete!(
-    tag!("seconds") => { |_| Unit::Second } |
-    tag!("second")  => { |_| Unit::Second } |
-    tag!("secs")    => { |_| Unit::Second } |
-    tag!("sec")     => { |_| Unit::Second } |
-    tag!("s")       => { |_| Unit::Second } |
-    tag!("minutes") => { |_| Unit::Minute } |
-    tag!("minute")  => { |_| Unit::Minute } |
-    tag!("mins")    => { |_| Unit::Minute } |
-    tag!("min")     => { |_| Unit::Minute } |
-    tag!("hours")   => { |_| Unit::Hour } |
-    tag!("hour")    => { |_| Unit::Hour } |
-    tag!("hrs")     => { |_| Unit::Hour } |
-    tag!("hr")      => { |_| Unit::Hour } |
-    tag!("days")    => { |_| Unit::Day } |
-    tag!("day")     => { |_| Unit::Day } |
-    tag!("d")       => { |_| Unit::Day } |
-    tag!("weeks")   => { |_| Unit::Week } |
-    tag!("week")    => { |_| Unit::Week } |
-    tag!("w")       => { |_| Unit::Week } |
-    tag!("months")  => { |_| Unit::Month } |
-    tag!("month")   => { |_| Unit::Month } |
-    tag!("years")   => { |_| Unit::Year } |
-    tag!("year")    => { |_| Unit::Year } |
-    tag!("yrs")     => { |_| Unit::Year }
-));
+pub fn unit_parser(input: &[u8]) -> IResult<&[u8], Unit> {
+    complete(alt((
+        map(alt((
+            tag("seconds"),
+            tag("second"),
+            tag("secs"),
+            tag("sec"),
+            tag("s"), )
+        ), |_| Unit::Second),
+        map(alt((
+            tag("minutes"),
+            tag("minute"),
+            tag("mins"),
+            tag("min"),
+        )), |_| Unit::Minute),
+        map(alt((
+            tag("hours"),
+            tag("hour"),
+            tag("hrs"),
+            tag("hr"),
+        )), |_| Unit::Hour),
+        map(alt((
+            tag("days"),
+            tag("day"),
+            tag("d"),
+        )), |_| Unit::Day),
+        map(alt((
+            tag("weeks"),
+            tag("week"),
+            tag("w"),
+        )), |_| Unit::Week),
+        map(alt((
+            tag("months"),
+            tag("month"),
+        )), |_| Unit::Month),
+        map(alt((
+            tag("years"),
+            tag("year"),
+            tag("yrs"),
+        )), |_| Unit::Year),
+    ))(input)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum Unit {
@@ -84,10 +101,12 @@ impl From<UnitAlias> for Unit {
     }
 }
 
-named!(pub operator_parser<Operator>, alt!(
-    tag!("+") => { |_| Operator::Plus } |
-    tag!("-") => { |_| Operator::Minus }
-));
+pub fn operator_parser(input: &[u8]) -> IResult<&[u8], Operator> {
+    alt((
+        map(tag("+"), |_| Operator::Plus),
+        map(tag("-"), |_| Operator::Minus),
+    ))(input)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum Operator {
@@ -95,20 +114,24 @@ pub enum Operator {
     Minus,
 }
 
-named!(pub unit_alias<UnitAlias>, alt_complete!(
-    tag!("secondly")  => { |_| UnitAlias::Secondly } |
-    tag!("minutely")  => { |_| UnitAlias::Minutely } |
-    tag!("hourly")    => { |_| UnitAlias::Hourly } |
-    tag!("daily")     => { |_| UnitAlias::Daily } |
-    tag!("weekly")    => { |_| UnitAlias::Weekly } |
-    tag!("monthly")   => { |_| UnitAlias::Monthly } |
-    tag!("yearly")    => { |_| UnitAlias::Yearly }
-));
-
-named!(pub amount_parser<Amount>, alt!(
-    do_parse!(number: integer >> unit: unit_parser >> (Amount(number, unit))) |
-    do_parse!(unitalias: unit_alias                >> (Amount(1, unitalias.into())))
-));
+pub fn unit_alias(input: &[u8]) -> IResult<&[u8], UnitAlias> {
+    complete(alt((
+        map(tag("secondly"), |_| UnitAlias::Secondly),
+        map(tag("minutely"), |_| UnitAlias::Minutely),
+        map(tag("hourly"), |_| UnitAlias::Hourly),
+        map(tag("daily"), |_| UnitAlias::Daily),
+        map(tag("weekly"), |_| UnitAlias::Weekly),
+        map(tag("monthly"), |_| UnitAlias::Monthly),
+        map(tag("yearly"), |_| UnitAlias::Yearly),
+    )))(input)
+}
+
+pub fn amount_parser(input: &[u8]) -> IResult<&[u8], Amount> {
+    alt((
+        map(tuple((integer, unit_parser)), |(number, unit)| Amount(number, unit)),
+        map(unit_alias, |unit| Amount(1, unit.into())),
+    ))(input)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Amount(i64, Unit);
@@ -127,19 +150,18 @@ impl IntoTimeType for Amount {
     }
 }
 
-named!(pub amount_expr_next<(Operator, Box<AmountExpr>)>, do_parse!(
-    op:operator_parser
-    >> opt!(sp)
-    >> amexp:amount_expr
-    >> ((op, Box::new(amexp)))
-));
+pub fn amount_expr_next(input: &[u8]) -> IResult<&[u8], (Operator, Box<AmountExpr>)> {
+    map(
+        tuple((operator_parser, multispace0, amount_expr)),
+        |(op, _, amexp)| (op, Box::new(amexp)),
+    )(input)
+}
 
-named!(pub amount_expr<AmountExpr>, do_parse!(
-    amount:amount_parser >>
-    opt!(sp) >>
-    o: opt!(complete!(amount_expr_next)) >>
-    (AmountExpr { amount, next: o, })
-));
+pub fn amount_expr(input: &[u8]) -> IResult<&[u8], AmountExpr> {
+    map(tuple((
+        amount_parser, multispace0, opt(complete(amount_expr_next)),
+    )), |(amount, _, next)| AmountExpr { amount, next })(input)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct AmountExpr {
@@ -162,17 +184,17 @@ impl IntoTimeType for AmountExpr {
     }
 }
 
-use iso8601::parsers::parse_date;
-use iso8601::parsers::parse_datetime;
 // The order is relevant here, because datetime is longer than date, we must parse datetime before
 // date.
-named!(pub exact_date_parser<ExactDate>, alt_complete!(
-    tag!("today")     => { |_| ExactDate::Today } |
-    tag!("yesterday") => { |_| ExactDate::Yesterday } |
-    tag!("tomorrow")  => { |_| ExactDate::Tomorrow } |
-    do_parse!(d: parse_datetime >> (ExactDate::Iso8601DateTime(d))) |
-    do_parse!(d: parse_date     >> (ExactDate::Iso8601Date(d)))
-));
+pub fn exact_date_parser(input: &[u8]) -> IResult<&[u8], ExactDate> {
+    complete(alt((
+        map(tag("today"), |_| ExactDate::Today),
+        map(tag("yesterday"), |_| ExactDate::Yesterday),
+        map(tag("tomorrow"), |_| ExactDate::Tomorrow),
+        map(parse_datetime, ExactDate::Iso8601DateTime),
+        map(parse_date, ExactDate::Iso8601Date),
+    )))(input)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum ExactDate {
@@ -252,13 +274,14 @@ impl IntoTimeType for ExactDate {
     }
 }
 
-named!(pub date<Date>, do_parse!(
-    exact: exact_date_parser >>
-    o: opt!(
-        complete!(do_parse!(sp >> op:operator_parser >> sp >> a:amount_expr >> (op, a)))
-    ) >>
-    (Date(exact, o))
-));
+pub fn date(input: &[u8]) -> IResult<&[u8], Date> {
+    map(
+        tuple((exact_date_parser,
+               opt(complete(map(tuple((multispace1, operator_parser, multispace1, amount_expr)), |(_, op, _, a)| (op, a))))
+        )),
+        |(exact, o)| Date(exact, o),
+    )(input)
+}
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Date(ExactDate, Option<(Operator, AmountExpr)>);
@@ -297,14 +320,15 @@ impl IntoTimeType for TimeType {
 // Note that this function returns a parser::TimeType, not a timetype::TimeType. Though, the
 // parser::TimeType can be `Into::into()`ed.
 //
-named!(pub timetype<TimeType>, alt!(
-    do_parse!(d: date        >> (TimeType::Date(d))) |
-    do_parse!(a: amount_expr >> (TimeType::AmountExpr(a)))
-));
+pub fn timetype(input: &[u8]) -> IResult<&[u8], TimeType> {
+    alt((
+        map(date, TimeType::Date),
+        map(amount_expr, TimeType::AmountExpr),
+    ))(input)
+}
 
 #[cfg(test)]
 mod tests {
-    use nom::IResult;
     use super::*;
 
     use chrono::Timelike;
@@ -312,99 +336,99 @@ mod tests {
 
     #[test]
     fn test_integer() {
-        assert_eq!(integer(&b"2"[..]), IResult::Done(&b""[..], 2));
-        assert_eq!(integer(&b"217"[..]), IResult::Done(&b""[..], 217));
+        assert_eq!(integer(&b"2"[..]), Ok((&b""[..], 2)));
+        assert_eq!(integer(&b"217"[..]), Ok((&b""[..], 217)));
     }
 
     #[test]
     fn test_unit() {
-        assert_eq!(unit_parser(&b"second"[..]), IResult::Done(&b""[..], Unit::Second));
-        assert_eq!(unit_parser(&b"seconds"[..]), IResult::Done(&b""[..], Unit::Second));
-        assert_eq!(unit_parser(&b"sec"[..]), IResult::Done(&b""[..], Unit::Second));
-        assert_eq!(unit_parser(&b"secs"[..]), IResult::Done(&b""[..], Unit::Second));
-        assert_eq!(unit_parser(&b"s"[..]), IResult::Done(&b""[..], Unit::Second));
-        assert_eq!(unit_parser(&b"minute"[..]), IResult::Done(&b""[..], Unit::Minute));
-        assert_eq!(unit_parser(&b"minutes"[..]), IResult::Done(&b""[..], Unit::Minute));
-        assert_eq!(unit_parser(&b"min"[..]), IResult::Done(&b""[..], Unit::Minute));
-        assert_eq!(unit_parser(&b"mins"[..]), IResult::Done(&b""[..], Unit::Minute));
-        assert_eq!(unit_parser(&b"hour"[..]), IResult::Done(&b""[..], Unit::Hour));
-        assert_eq!(unit_parser(&b"hours"[..]), IResult::Done(&b""[..], Unit::Hour));
-        assert_eq!(unit_parser(&b"hr"[..]), IResult::Done(&b""[..], Unit::Hour));
-        assert_eq!(unit_parser(&b"hrs"[..]), IResult::Done(&b""[..], Unit::Hour));
-        assert_eq!(unit_parser(&b"day"[..]), IResult::Done(&b""[..], Unit::Day));
-        assert_eq!(unit_parser(&b"days"[..]), IResult::Done(&b""[..], Unit::Day));
-        assert_eq!(unit_parser(&b"d"[..]), IResult::Done(&b""[..], Unit::Day));
-        assert_eq!(unit_parser(&b"week"[..]), IResult::Done(&b""[..], Unit::Week));
-        assert_eq!(unit_parser(&b"weeks"[..]), IResult::Done(&b""[..], Unit::Week));
-        assert_eq!(unit_parser(&b"w"[..]), IResult::Done(&b""[..], Unit::Week));
-        assert_eq!(unit_parser(&b"month"[..]), IResult::Done(&b""[..], Unit::Month));
-        assert_eq!(unit_parser(&b"months"[..]), IResult::Done(&b""[..], Unit::Month));
-        assert_eq!(unit_parser(&b"year"[..]), IResult::Done(&b""[..], Unit::Year));
-        assert_eq!(unit_parser(&b"years"[..]), IResult::Done(&b""[..], Unit::Year));
-        assert_eq!(unit_parser(&b"yrs"[..]), IResult::Done(&b""[..], Unit::Year));
+        assert_eq!(unit_parser(&b"second"[..]), Ok((&b""[..], Unit::Second)));
+        assert_eq!(unit_parser(&b"seconds"[..]), Ok((&b""[..], Unit::Second)));
+        assert_eq!(unit_parser(&b"sec"[..]), Ok((&b""[..], Unit::Second)));
+        assert_eq!(unit_parser(&b"secs"[..]), Ok((&b""[..], Unit::Second)));
+        assert_eq!(unit_parser(&b"s"[..]), Ok((&b""[..], Unit::Second)));
+        assert_eq!(unit_parser(&b"minute"[..]), Ok((&b""[..], Unit::Minute)));
+        assert_eq!(unit_parser(&b"minutes"[..]), Ok((&b""[..], Unit::Minute)));
+        assert_eq!(unit_parser(&b"min"[..]), Ok((&b""[..], Unit::Minute)));
+        assert_eq!(unit_parser(&b"mins"[..]), Ok((&b""[..], Unit::Minute)));
+        assert_eq!(unit_parser(&b"hour"[..]), Ok((&b""[..], Unit::Hour)));
+        assert_eq!(unit_parser(&b"hours"[..]), Ok((&b""[..], Unit::Hour)));
+        assert_eq!(unit_parser(&b"hr"[..]), Ok((&b""[..], Unit::Hour)));
+        assert_eq!(unit_parser(&b"hrs"[..]), Ok((&b""[..], Unit::Hour)));
+        assert_eq!(unit_parser(&b"day"[..]), Ok((&b""[..], Unit::Day)));
+        assert_eq!(unit_parser(&b"days"[..]), Ok((&b""[..], Unit::Day)));
+        assert_eq!(unit_parser(&b"d"[..]), Ok((&b""[..], Unit::Day)));
+        assert_eq!(unit_parser(&b"week"[..]), Ok((&b""[..], Unit::Week)));
+        assert_eq!(unit_parser(&b"weeks"[..]), Ok((&b""[..], Unit::Week)));
+        assert_eq!(unit_parser(&b"w"[..]), Ok((&b""[..], Unit::Week)));
+        assert_eq!(unit_parser(&b"month"[..]), Ok((&b""[..], Unit::Month)));
+        assert_eq!(unit_parser(&b"months"[..]), Ok((&b""[..], Unit::Month)));
+        assert_eq!(unit_parser(&b"year"[..]), Ok((&b""[..], Unit::Year)));
+        assert_eq!(unit_parser(&b"years"[..]), Ok((&b""[..], Unit::Year)));
+        assert_eq!(unit_parser(&b"yrs"[..]), Ok((&b""[..], Unit::Year)));
     }
 
     #[test]
     fn test_unit_alias() {
-        assert_eq!(unit_alias(&b"secondly"[..]), IResult::Done(&b""[..], UnitAlias::Secondly));
-        assert_eq!(unit_alias(&b"minutely"[..]), IResult::Done(&b""[..], UnitAlias::Minutely));
-        assert_eq!(unit_alias(&b"hourly"[..]), IResult::Done(&b""[..], UnitAlias::Hourly));
-        assert_eq!(unit_alias(&b"daily"[..]), IResult::Done(&b""[..], UnitAlias::Daily));
-        assert_eq!(unit_alias(&b"weekly"[..]), IResult::Done(&b""[..], UnitAlias::Weekly));
-        assert_eq!(unit_alias(&b"monthly"[..]), IResult::Done(&b""[..], UnitAlias::Monthly));
-        assert_eq!(unit_alias(&b"yearly"[..]), IResult::Done(&b""[..], UnitAlias::Yearly));
+        assert_eq!(unit_alias(&b"secondly"[..]), Ok((&b""[..], UnitAlias::Secondly)));
+        assert_eq!(unit_alias(&b"minutely"[..]), Ok((&b""[..], UnitAlias::Minutely)));
+        assert_eq!(unit_alias(&b"hourly"[..]), Ok((&b""[..], UnitAlias::Hourly)));
+        assert_eq!(unit_alias(&b"daily"[..]), Ok((&b""[..], UnitAlias::Daily)));
+        assert_eq!(unit_alias(&b"weekly"[..]), Ok((&b""[..], UnitAlias::Weekly)));
+        assert_eq!(unit_alias(&b"monthly"[..]), Ok((&b""[..], UnitAlias::Monthly)));
+        assert_eq!(unit_alias(&b"yearly"[..]), Ok((&b""[..], UnitAlias::Yearly)));
     }
 
     #[test]
     fn test_operator() {
-        assert_eq!(operator_parser(&b"+"[..]), IResult::Done(&b""[..], Operator::Plus));
-        assert_eq!(operator_parser(&b"-"[..]), IResult::Done(&b""[..], Operator::Minus));
+        assert_eq!(operator_parser(&b"+"[..]), Ok((&b""[..], Operator::Plus)));
+        assert_eq!(operator_parser(&b"-"[..]), Ok((&b""[..], Operator::Minus)));
     }
 
     #[test]
     fn test_amount() {
-        assert_eq!(amount_parser(&b"5s"[..]), IResult::Done(&b""[..], Amount(5, Unit::Second)));
-        assert_eq!(amount_parser(&b"5min"[..]), IResult::Done(&b""[..], Amount(5, Unit::Minute)));
-        assert_eq!(amount_parser(&b"55hrs"[..]), IResult::Done(&b""[..], Amount(55, Unit::Hour)));
-        assert_eq!(amount_parser(&b"25days"[..]), IResult::Done(&b""[..], Amount(25, Unit::Day)));
-        assert_eq!(amount_parser(&b"15weeks"[..]), IResult::Done(&b""[..], Amount(15, Unit::Week)));
+        assert_eq!(amount_parser(&b"5s"[..]), Ok((&b""[..], Amount(5, Unit::Second))));
+        assert_eq!(amount_parser(&b"5min"[..]), Ok((&b""[..], Amount(5, Unit::Minute))));
+        assert_eq!(amount_parser(&b"55hrs"[..]), Ok((&b""[..], Amount(55, Unit::Hour))));
+        assert_eq!(amount_parser(&b"25days"[..]), Ok((&b""[..], Amount(25, Unit::Day))));
+        assert_eq!(amount_parser(&b"15weeks"[..]), Ok((&b""[..], Amount(15, Unit::Week))));
     }
 
     #[test]
     fn test_unit_alias_with_amount_parser() {
-        assert_eq!(amount_parser(&b"secondly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Second)));
-        assert_eq!(amount_parser(&b"minutely"[..]), IResult::Done(&b""[..], Amount(1, Unit::Minute)));
-        assert_eq!(amount_parser(&b"hourly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Hour)));
-        assert_eq!(amount_parser(&b"daily"[..]), IResult::Done(&b""[..], Amount(1, Unit::Day)));
-        assert_eq!(amount_parser(&b"weekly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Week)));
-        assert_eq!(amount_parser(&b"monthly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Month)));
-        assert_eq!(amount_parser(&b"yearly"[..]), IResult::Done(&b""[..], Amount(1, Unit::Year)));
+        assert_eq!(amount_parser(&b"secondly"[..]), Ok((&b""[..], Amount(1, Unit::Second))));
+        assert_eq!(amount_parser(&b"minutely"[..]), Ok((&b""[..], Amount(1, Unit::Minute))));
+        assert_eq!(amount_parser(&b"hourly"[..]), Ok((&b""[..], Amount(1, Unit::Hour))));
+        assert_eq!(amount_parser(&b"daily"[..]), Ok((&b""[..], Amount(1, Unit::Day))));
+        assert_eq!(amount_parser(&b"weekly"[..]), Ok((&b""[..], Amount(1, Unit::Week))));
+        assert_eq!(amount_parser(&b"monthly"[..]), Ok((&b""[..], Amount(1, Unit::Month))));
+        assert_eq!(amount_parser(&b"yearly"[..]), Ok((&b""[..], Amount(1, Unit::Year))));
     }
 
 
     #[test]
     fn test_amountexpr_next() {
         assert_eq!(amount_expr_next(&b"+ 12minutes"[..]),
-            IResult::Done(&b""[..],
+                   Ok((&b""[..],
                 (
                     Operator::Plus,
                     Box::new(AmountExpr { amount: Amount(12, Unit::Minute), next: None })
                 )
-        ));
+        )));
     }
 
     #[test]
     fn test_amountexpr() {
         assert_eq!(amount_expr(&b"5minutes"[..]),
-            IResult::Done(&b""[..],
+                   Ok((&b""[..],
                           AmountExpr {
                               amount: Amount(5, Unit::Minute),
                               next: None
                           })
-        );
+        ));
 
         assert_eq!(amount_expr(&b"5min + 12min"[..]),
-        IResult::Done(&b""[..],
+                   Ok((&b""[..],
                       AmountExpr {
                           amount: Amount(5, Unit::Minute),
                           next: Some((Operator::Plus, Box::new(
@@ -412,14 +436,14 @@ mod tests {
                                           amount: Amount(12, Unit::Minute),
                                           next: None
                                       })))
-                      }));
+                      })));
     }
 
     #[test]
     fn test_parse_expressions_date() {
         use iso8601::Date;
         let res = exact_date_parser(&b"2017-01-01"[..]);
-        assert!(res.is_done());
+        assert!(res.is_ok());
 
         match res.unwrap().1 {
             ExactDate::Iso8601DateTime(_) => panic!("Unexpected enum variant"),
@@ -443,7 +467,7 @@ mod tests {
     fn test_parse_expressions_datetime() {
         use iso8601::Date;
         let res = exact_date_parser(&b"2017-01-01T22:00:11"[..]);
-        assert!(res.is_done());
+        assert!(res.is_ok());
 
         match res.unwrap().1 {
             ExactDate::Iso8601DateTime(obj) => {
@@ -469,16 +493,16 @@ mod tests {
     #[test]
     fn test_simple_date_1() {
         let res = exact_date_parser(&b"today"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
 
         let res = date(&b"today"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
     }
 
     #[test]
     fn test_simple_date_2() {
         let res = date(&b"2017-01-01"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, o) = res.unwrap();
 
         println!("{:#?}", o);
@@ -501,7 +525,7 @@ mod tests {
     #[test]
     fn test_simple_date_3() {
         let res = date(&b"2017-01-01T01:02:03"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res);
+        assert!(res.is_ok(), "Not done: {:?}", res);
         let (_, o) = res.unwrap();
 
         println!("{:#?}", o);
@@ -524,7 +548,7 @@ mod tests {
     #[test]
     fn test_expressions_to_date() {
         let res = amount_expr(&b"5min + 12min"[..]);
-        assert!(res.is_done());
+        assert!(res.is_ok());
         let (_, o) = res.unwrap();
 
         let calc_res : timetype::TimeType = o.into_timetype().unwrap();
@@ -542,7 +566,7 @@ mod tests {
     #[test]
     fn test_expressions_to_date_2() {
         let res = amount_expr(&b"5min + 12min + 15hours"[..]);
-        assert!(res.is_done());
+        assert!(res.is_ok());
         let (_, o) = res.unwrap();
 
         let calc_res : timetype::TimeType = o.into_timetype().unwrap();
@@ -560,7 +584,7 @@ mod tests {
     #[test]
     fn test_expressions_to_date_3() {
         let res = date(&b"today + 5min + 12min"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res.unwrap_err().description());
+        assert!(res.is_ok(), "Not done: {:?}", res.unwrap_err());
         let (_, o) = res.unwrap();
 
         let calc_res : timetype::TimeType = o.into_timetype().unwrap();
@@ -575,7 +599,7 @@ mod tests {
     #[test]
     fn test_expressions_to_date_4() {
         let res = date(&b"2017-01-01 + 5min + 12min"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res.unwrap_err().description());
+        assert!(res.is_ok(), "Not done: {:?}", res.unwrap_err());
         let (_, o) = res.unwrap();
 
         println!("{:#?}", o);
@@ -598,7 +622,7 @@ mod tests {
     #[test]
     fn test_expressions_to_timetype() {
         let res = timetype(&b"5min + 12min + 15hours"[..]);
-        assert!(res.is_done());
+        assert!(res.is_ok());
         let (_, o) = res.unwrap();
 
         let calc_res : ::timetype::TimeType = o.into_timetype().unwrap();
@@ -616,7 +640,7 @@ mod tests {
     #[test]
     fn test_expressions_to_timetype_2() {
         let res = timetype(&b"today + 5min + 12min"[..]);
-        assert!(res.is_done(), "Not done: {:?}", res.unwrap_err().description());
+        assert!(res.is_ok(), "Not done: {:?}", res.unwrap_err());
         let (_, o) = res.unwrap();
 
         let calc_res : ::timetype::TimeType = o.into_timetype().unwrap();
@@ -631,7 +655,7 @@ mod tests {
     #[test]
     fn test_expressions_to_timetype_subtract() {
         let res = timetype(&b"5min + 12min + 15hours - 1hour"[..]);
-        assert!(res.is_done());
+        assert!(res.is_ok());
         let (_, o) = res.unwrap();
 
         println!("{:#?}", o);