Function expr

saffron/src/parse.rs:744–783

A parser that can parse delimited expressions given a parser for that part. This can't parse day of the month or week expressions.

(f: F)

/// A parser that can parse delimited expressions given a parser for that part.
/// This can't parse day of the month or week expressions.
fn expr<E, F>(f: F) -> impl Fn(&str) -> IResult<&str, Expr<E>>
where
    E: ExprValue + TryFrom<u8, Error = ValueOutOfRangeError> + Ord + Copy,
    F: Fn(&str) -> IResult<&str, E>,
{
    move |mut input: &str| {
        let expressions: Exprs<E>;
        // Attempt to read a `*`. If that succeeds,
        // try to read a `/` for a step expr.
        // If this isn't a step expr, return Expr::All,
        // If it's not a `*`, initialize the expressions
        // list with an ors_expr.
        let star = opt(char('*'))(input)?;
        input = star.0;
        if star.1.is_some() {
            let slash = opt(char('/'))(input)?;
            input = slash.0;
            // If there is no slash after this, just return All and expect the next
            // parser to fail if it's invalid
            if slash.1.is_none() {
                return Ok((input, Expr::All));
            }
            let step = step_digit::<E>()(input)?;
            input = step.0;
            expressions = Exprs::new(OrsExpr::Step {
                start: ExprValue::min(),
                end: ExprValue::max(),
                step: step.1,
            })
        } else {
            let expr = ors_expr::<E, _>(&f)(input)?;
            input = expr.0;
            expressions = Exprs::new(expr.1)
        }

        let (input, exprs) = tail_ors_exprs(input, &f, expressions)?;

        Ok((input, Expr::Many(exprs)))
    }
}

#[inline]
fn map_digit1<E>() -> impl Fn(&str) -> IResult<&str, E>