Using auto to Return Different Lambdas

user_2642059 0
Viewed 973

So I'm curious if c++17 gives me the flexibility to do this. I have this answer which contains the code:

template <typename T>
function<void(vector<pair<T, T>>&)> vertex_triangle(const size_t index, const vector<pair<T, T>>& polygon) {
    if (0U == index){
        return [&](vector<pair<T, T>>& output){ output.push_back(polygon.back());
                                                output.push_back(polygon.front());
                                                output.push_back(polygon[1U]); };
    }else if (index == (polygon.size() - 1U)){
        return [&](vector<pair<T, T>>& output){ output.push_back(polygon[polygon.size() - 2U]);
                                                output.push_back(polygon.back());
                                                output.push_back(polygon.front()); };
    }else{
        return [&](vector<pair<T, T>>& output){ output.push_back(polygon[index - 1U]);
                                                output.push_back(polygon[index]);
                                                output.push_back(polygon[index + 1U]); };
    }
}

I think that I should be able to change the function signature to: auto vertex_triangle(const size_t index, const vector<pair<T, T>>& polygon) thereby preserving closure type optimization. Additionally I'd really like to have my lambda parameter be auto& rather than vector<pair<T, T>>&.
Would c++17 support these changes?

auto c++17 closures lambda c++
2 Answers

Would c++17 support these changes?

No. What you're asking for is to have a function that returns different types depending on a runtime condition. The only way to do that is type erasure - whether of the std::function kind or the standard OOP inheritance kind.

If you could lift the conditions to constant expressions, then you could accomplish this with if constexpr (or simply tag dispatching). But given that the second case is index == vector.size() - 1, I'm guessing this isn't possible.

That said, do you actually need different functions? Why not (NB: capture index by copy to avoid dangling reference):

template <typename T>
auto vertex_triangle(const size_t index, const vector<pair<T, T>>& polygon) {
    return [&polygon, index](vector<pair<T, T>>& output){ 
        size_t lo = index == 0 ? polygon.size() - 1 : index - 1;
        size_t hi = index == polygon.size() - 1 ? 0 : index + 1;

        for (size_t offset : {lo, index, hi}) {       
            output.push_back(polygon[offset]);
        }
    };
}
user_20690640

No, the return type of a function cannot vary based off of non-template value function arguments.

You could write a variant factory like this:

template<class F, class T, T t, T...ts>
auto variant_from(
  F&& f,
  std::integral_constant<T, t> which,
  std::integer_sequence<T, ts...>
) ->
std::variant< std::decay_t<
  std::result_of_t< F&&( std::integral_constant<T, t>)>
>... > {
  return std::forward<F>(f)( which );
}

using this we can return a variant over the lambdas, which is about as close as you can get.

template <typename T>
auto vertex_triangle(const size_t index, const vector<pair<T, T>>& polygon) {
  auto choice_list = std::make_index_sequence<3>{};
  auto algorithm = [&polygon, index](auto choice) {
    if constexpr (choice==0){
      return [&polygon](vector<pair<T, T>>& output){ 
        output.push_back(polygon.back());
        output.push_back(polygon.front());    
        output.push_back(polygon[1U]);
      };
    }else if constexpr (choice == 1){
      return [&polygon](vector<pair<T, T>>& output){
        output.push_back(polygon[polygon.size() - 2U]);
        output.push_back(polygon.back());
        output.push_back(polygon.front());
      };
    }else{
      return [&polygon, index](vector<pair<T, T>>& output){
        output.push_back(polygon[index - 1U]);
        output.push_back(polygon[index]);
        output.push_back(polygon[index + 1U]); };
      }
    };
  if (index == 0)
    return variant_from( algorithm, std::integral_constant<std::size_t, 0>{}, choice_list );
  else if (index == output.size()-1)
    return variant_from( algorithm, std::integral_constant<std::size_t, 1>{}, choice_list );
  else
    return variant_from( algorithm, std::integral_constant<std::size_t, 2>{}, choice_list );
}

I'm sure that can be cleaned up a bit.

variant_from uses the algorithm to deduce what the variant is a sum type over, then only stores one of them in the returned variant. We call it in 3 different contexts that have the same return type, but a different value stored.

Note that operator() on variant doesn't do what we want, but we can augment it.

user_17746670
Related