1

I want the following code to compile and work:

#include <boost/hana/group.hpp>
#include <functional>
#include <vector>
int main() {
    std::vector<int> x = {1,1,3,4};
    auto groups = boost::hana::group(x, std::equal_to<>{});
}

An attempt to compile errors like this:

$ g++ -std=c++2a deleteme.cpp && ./a.out
In file included from deleteme.cpp:1:
/usr/include/boost/hana/group.hpp: In instantiation of ‘constexpr auto boost::hana::group_t::operator()(Xs&&, Predicate&&) const [with Xs = std::vector<int>&; Predicate = std::equal_to<void>]’:
deleteme.cpp:6:44:   required from here
/usr/include/boost/hana/group.hpp:55:42: error: static assertion failed: hana::group(xs, predicate) requires 'xs' to be a Sequence
   55 |         static_assert(hana::Sequence<S>::value,
      |                                          ^~~~~
/usr/include/boost/hana/group.hpp:59:28: error: use of deleted function ‘static constexpr auto boost::hana::deleted_implementation::apply(T&& ...) [with T = {std::vector<int, std::allocator<int> >&, std::equal_to<void>}]’
   59 |         return Group::apply(static_cast<Xs&&>(xs),
      |                ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
   60 |                             static_cast<Predicate&&>(pred));
      |                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/boost/hana/core/dispatch.hpp:14,
                 from /usr/include/boost/hana/drop_front.hpp:18,
                 from /usr/include/boost/hana/concept/iterable.hpp:20,
                 from /usr/include/boost/hana/at.hpp:16,
                 from /usr/include/boost/hana/group.hpp:15,
                 from deleteme.cpp:1:
/usr/include/boost/hana/detail/dispatch_if.hpp:21:31: note: declared here
   21 |         static constexpr auto apply(T&& ...) = delete;
      |                               ^~~~~

Therefore I understand that the reason is that std::vector does not satisfy the concept of Sequence, but how do I enforce that it does?

I've been giving a look at /usr/include/boost/hana/fwd/concept/sequence.hpp and /usr/include/boost/hana/concept/sequence.hpp, but for now the template meta-metaprogramming in those files is still a bit to heavy for me to understand it without any help.

This is an excerpt from Hana's documentation, which I think addresses the question. The point is that I don't how I can translate that prescriptions to code:

For this reason, it is necessary to specialize the Sequence metafunction in Hana's namespace to tell Hana that a type is indeed a Sequence. Explicitly specializing the Sequence metafunction can be seen like a seal saying "this data type satisfies the additional laws of a Sequence", since those can't be checked by Hana automatically.

Enlico
  • 23,259
  • 6
  • 48
  • 102
  • You can't enforce a standard library type that you didn't write to match a concept you didn't write?? – Bayleef Aug 14 '20 at 18:55
  • @BaileyKocin id you really think this, give a shape to your thoughts and post an answer with the proof. – Enlico Aug 14 '20 at 19:00
  • I'm questioning your question because its not logically possible. – Bayleef Aug 14 '20 at 19:01
  • It actually is impossible unless you supply your own compiler libs – Bayleef Aug 14 '20 at 19:02
  • @BaileyKocin then write an answer which proves your statement with something more specific than _you cannot_ and _it's impossible_. – Enlico Aug 14 '20 at 19:04
  • Its common sense. – Bayleef Aug 14 '20 at 19:04
  • You didn't implement c++ how would you change a concept you didn't write? – Bayleef Aug 14 '20 at 19:05
  • @BaileyKocin because the library offers templates that I can specialize on other types to make those types satisfy concepts that makes those types suitable for the library's functions. Please read the edit to my question. – Enlico Aug 14 '20 at 19:11

1 Answers1

1

While it is possible to implement some of the concepts in Boost.Hana with types that involve different dimensions known only at run-time, Boost.Hana.Sequence and some of the concepts that are a part of its "Minimal Complete Definition" require length and elements to be known at compile-time.

  • Foldable requires that the length be known at compile-time.
  • Iterable requires that each element be accessible at compile-time.
  • Sequence requires Foldable and Iterable.

The group function requiring a Sequence and the run-time length of std::vector make this impossible.

The section Computational Quadrants in the Boost.Hana manual elaborates on algorithms requiring compile-time vs run-time information.

(The Group concept is likely doable, but I don't think that is part of the question.)

Regarding the comments about specializing third party templates for standard types, it is possible but considered bad form. The solution is to make a wrapper type of some kind or provide your own concepts.

Edit:

A comment suggested an example of implementing std::array as a Sequence since its length is known at compile-time. While I can't find a silver bullet in the "Laws" of Sequence that forbid homogeneously typed lists, I can say that the premise of Sequence is working with heterogeneously typed data structures. Elements may contain run-time data, but all of the predicates in the algorithms rely exclusively on "compile-time" information so functions like group would be completely useless for std::array. (This is explained in the aforementioned link)

Jason Rice
  • 1,686
  • 1
  • 12
  • 17
  • Concerning specializing [...], the excerpt, from Boost.Hana's documentation, at the end of my question seems to suggest that specializing is the way to go, so why do you say _bad form_? However, if the problem is `std::vector` having a runtime lenght, the could you give an example for `std::array`, which has a lenght known at compile time? – Enlico Aug 15 '20 at 04:36
  • 1
    Specializing `Sequence` fine, but if you specialize it for a standard type, you are possibly breaking compatibility with versions of Boost.Hana that might elect to specialize it. – Jason Rice Aug 15 '20 at 22:51
  • An example of implementing `Sequence`: https://stackoverflow.com/a/61879631/800347 – Jason Rice Aug 17 '20 at 05:35