Function pipeline

prqlc/prqlc-parser/src/parser/expr.rs:340–368

A pipeline of `expr`, separated by pipes. Doesn't require parentheses.

(expr: E)

/// A pipeline of `expr`, separated by pipes. Doesn't require parentheses.
pub(crate) fn pipeline<'a, I, E>(expr: E) -> impl Parser<'a, I, Expr, ParserError<'a>> + Clone + 'a
where
    I: Input<'a, Token = lr::Token, Span = Span> + BorrowInput<'a>,
    E: Parser<'a, I, Expr, ParserError<'a>> + Clone + 'a,
{
    // expr has to be a param, because it can be either a normal expr() or a
    // recursive expr called from within expr(), which causes a stack overflow

    // TODO: do we need the `maybe_aliased` here rather than in `expr`? We had
    // tried `with_doc_comment(expr)` in #4775 (and push an aliased expr into
    // `expr`) but couldn't get it work.
    with_doc_comment(maybe_aliased(expr))
        .separated_by(pipe())
        .at_least(1)
        .collect::<Vec<_>>()
        .map_with(|exprs: Vec<Expr>, extra| {
            let span = extra.span();
            // If there's only one expr, then we don't need to wrap it
            // in a pipeline — just return the lone expr. Otherwise,
            // wrap them in a pipeline.
            exprs.into_iter().exactly_one().unwrap_or_else(|exprs| {
                ExprKind::Pipeline(Pipeline {
                    exprs: exprs.collect(),
                })
                .into_expr(span)
            })
        })
        .labelled("pipeline")
}

// Can remove if we don't end up using this
#[allow(dead_code)]