Function parse_apply

src/expr-parser/src/parser.rs:1141–1184

(input: ParseStream)

    }

    fn parse_apply(input: ParseStream) -> Result {
        let ident = input.parse::<syn::Ident>()?;

        // parse parentheses
        let inner;
        syn::parenthesized!(inner in input);

        let parse_nullary = |func: UnmaterializableFunc| -> Result {
            Ok(MirScalarExpr::CallUnmaterializable(func))
        };
        let parse_unary = |func: UnaryFunc| -> Result {
            let expr = Box::new(parse_expr(&inner)?);
            Ok(MirScalarExpr::CallUnary { func, expr })
        };
        let parse_binary = |func: BinaryFunc| -> Result {
            let expr1 = Box::new(parse_expr(&inner)?);
            inner.parse::<syn::Token![,]>()?;
            let expr2 = Box::new(parse_expr(&inner)?);
            Ok(MirScalarExpr::CallBinary { func, expr1, expr2 })
        };
        let parse_variadic = |func: VariadicFunc| -> Result {
            let exprs = inner.parse_comma_sep(parse_expr)?;
            Ok(MirScalarExpr::call_variadic(func, exprs))
        };

        // Infix binary and variadic function calls are handled in `parse_scalar_expr`.
        //
        // Some restrictions apply with the current state of the code,
        // most notably one cannot handle overloaded function names because we don't want to do
        // name resolution in the parser.
        match ident.to_string().to_lowercase().as_str() {
            // Supported unmaterializable (a.k.a. nullary) functions:
            "mz_environment_id" => parse_nullary(UnmaterializableFunc::MzEnvironmentId),
            // Supported unary functions:
            "abs" => parse_unary(func::AbsInt64.into()),
            "not" => parse_unary(func::Not.into()),
            // Supported binary functions:
            "ltrim" => parse_binary(func::TrimLeading.into()),
            // Supported variadic functions:
            "greatest" => parse_variadic(VariadicFunc::Greatest(func::variadic::Greatest)),
            "coalesce" => parse_variadic(VariadicFunc::Coalesce(func::variadic::Coalesce)),
            _ => Err(Error::new(ident.span(), "unsupported function name")),
        }
    }

    pub fn parse_join_equivalences(input: ParseStream) -> syn::Result<Vec<Vec<MirScalarExpr>>> {
        let mut equivalences = vec![];