CoCoA » CoCoALib

Florian reports problems compiling the following mini-prog using gcc-11.

#include <vector>
#include <iostream>
#include <algorithm>

#include <tuple>
using namespace std;

  class BASE
  {
  public:
    BASE(): datum(0) {}
  private:
    int datum;
  };

  class DERIV: public BASE
  {
  public:
    DERIV(): BASE(), datum2(1) {}
  private:
    int datum2;
  };

  class Function
  {
  public:
    Function() {}
    int operator()(const BASE& b) const { return 2; }
  };

  template <typename T>
  std::vector<int> apply(const Function& F, const std::vector<T>& v)
  {
    std::vector<int> ans;
    std::transform(v.begin(), v.end(), std::back_inserter(ans), [&F](const T& x){ return F(x); });
    return ans;
  }

  int main()
  {
    std::vector<DERIV> v(2,DERIV());
    Function F;
    std::vector<int> vv = apply(F,v);
    std::cout << v.size() << std::endl;
    for (int i: vv)  std::cout << i << std::endl;
  }

ERROR message is (in german):

In Datei, eingebunden von /usr/include/c++/11.1.0/functional:54,
                 von /usr/include/c++/11.1.0/pstl/glue_algorithm_defs.h:13,
                 von /usr/include/c++/11.1.0/algorithm:74,
                 von test.c:3:
/usr/include/c++/11.1.0/tuple: In Instanziierung von »constexpr const size_t std::tuple_size_v<std::vector<DERIV> >«:
/usr/include/c++/11.1.0/tuple:1816:24:   erfordert durch »constexpr decltype(auto) std::apply(_Fn&&, _Tuple&&) [mit _Fn = Function&; _Tuple = std::vector<DERIV>&]«
test.c:43:32:   von hier erfordert
/usr/include/c++/11.1.0/tuple:1334:61: Fehler: unvollständiger Typ »std::tuple_size<std::vector<DERIV> >« in geschachtelter Namensangabe verwendet
 1334 |     inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
      |                                                             ^~~~~

I have now modified apply.H so that the apply function for vectors is just a normal function (rather than a pointless template fn).
Amazingly, on Florian's computer (Arch Linux with gcc-11.1) the compiler still prefers std::apply over the non-template apply fn.
What is going on?

Other compilers have no problem!

I do note that cppreference states that std::apply is available from c++17 onwards.
Perhaps Florian needs a flag to limit to the c++14 standard... but that is not a good long-term solution.

Grrr!

This particular problem has been resolved (by eliminating the apply fn from CoCoALib).
In this case the removal has led to neater code (I think).

What I do not like is the looming problem of future versions of C++ hiding CoCoALib functions with the same name.
This is a worrying/nasty aspect of new changes introduced into C++; perhaps jumping to C++20, and hoping that
restrictions/constraints on the STL template fn will avoid the problem. Need outside help for this!

Let's cross our fingers and hope that the problem has gone away by the time we jump to C++20.
Closing this issue.... probably a new similar one will appear at some point (sigh).