Function ListSortByMacro

extensions/lists_functions.cc:432–478

This macro transforms an expression like: mylistExpr.sortBy(e, -math.abs(e)) into something equivalent to: cel.bind( @__sortBy_input__, myListExpr, @__sortBy_input__.@sortByAssociatedKeys( @__sortBy_input__.map(e, -math.abs(e) ) )

//      )
//    )
Macro ListSortByMacro() {
  absl::StatusOr<Macro> sortby_macro = Macro::Receiver(
      "sortBy", 2,
      [](MacroExprFactory& factory, Expr& target,
         absl::Span<Expr> args) -> absl::optional<Expr> {
        if (!target.has_ident_expr() && !target.has_select_expr() &&
            !target.has_list_expr() && !target.has_comprehension_expr() &&
            !target.has_call_expr()) {
          return factory.ReportErrorAt(
              target,
              "sortBy can only be applied to a list, identifier, "
              "comprehension, call or select expression");
        }

        auto sortby_input_ident = factory.NewIdent("@__sortBy_input__");
        auto sortby_input_expr = std::move(target);
        auto key_ident = std::move(args[0]);
        auto key_expr = std::move(args[1]);

        // Build the map expression:
        //   map_compr := @__sortBy_input__.map(key_ident, key_expr)
        auto map_compr =
            MakeMapComprehension(factory, factory.Copy(sortby_input_ident),
                                 std::move(key_ident), std::move(key_expr));
        if (!map_compr.has_value()) {
          return absl::nullopt;
        }

        // Build the call expression:
        //   call_expr := @__sortBy_input__.@sortByAssociatedKeys(map_compr)
        std::vector<Expr> call_args;
        call_args.push_back(std::move(*map_compr));
        auto call_expr = factory.NewMemberCall("@sortByAssociatedKeys",
                                               std::move(sortby_input_ident),
                                               absl::MakeSpan(call_args));

        // Build the returned bind expression:
        //   cel.bind(@__sortBy_input__, target, call_expr)
        auto var_ident = factory.NewIdent("@__sortBy_input__");
        auto var_expr = std::move(sortby_input_expr);
        auto bind_compr =
            MakeBindComprehension(factory, std::move(var_ident),
                                  std::move(var_expr), std::move(call_expr));
        return bind_compr;
      });
  return *sortby_macro;
}

absl::StatusOr<Value> ListSort(
    const ListValue& list,