@ldionne Thanks for closing boostorg/hana#341. I've got some free cycles. Rather than choosing any issue myself, I would like to know if there's any high priority issue to be solved. I'm now getting quite comfortable with hana. I can try to solve issues with easy to medium difficulty. Or if there's any other big task/feature that you're up to and I can contribute to, let me know.
This is going to be huge, but I’m stuggling to setup time for it.
Another thing that would be useful is to add a concept for those set theoretic operations.
Otherwise, lots of issues are either documentation-related, performance-related, or quite tricky metaprogramming/generic programming problems (e.g. the trivially-constructible pair stuff). Not sure how much that interests you, but if so you can pick anything you’d like.
Btw, I think what this points out is the fact that iterators are indeed useful for some use cases.
I'm guessing they are non const references right now to prevent temporaries. Is that the reason?
We may want to modify the elements of the container or we might not, for example.
Also, they’re only held by reference when they’re a container, cause views are held by value.
I mean, do play with it by any means, but don’t wait to ask questions
Looks like a big video, will have a look as time permits
Is monadic_fold_left the best way to flatten something like this (an edge list)...
hana::tuple<
hana::pair<A, B>,
hana::pair<A, C>,
hana::pair<A, D>,
hana::pair<B, C>,
hana::pair<B, D>>...into something like this (an adjacency list)?
hana::tuple<
hana::pair<A, hana::tuple<B, C, D>>,
hana::pair<B, hana::tuple<C, D>>>
I have a couple of use cases for one
Having it build a map would be ideal (I think)
perhaps ignore that code I posted in there :P
Clang 4 and Clang 5 give weird constexpr errors here (compiler bug?), and GCC 7 doesn't yield the result I would expect. Trying to group by first type in a pair -- is my predicate wrong? I think so, because the ordering of the input tuple elements affects the output type by more than just the output order. What's the best way to do this?
#include <utility>
#include <type_traits>
#include <boost/hana.hpp>
namespace hana = boost::hana;
struct A{};
struct B{};
struct C{};
struct D{};
int main() {
auto grouped = hana::group(
hana::make_tuple(
std::pair<A, B>{},
std::pair<A, C>{},
std::pair<B, C>{},
std::pair<A, D>{},
std::pair<B, D>{}),
hana::comparing([](auto t){ return hana::type_c<decltype(t.first)>; }));
// print type as error message
decltype(grouped)::asdfasdfasdf();
}
@badair That looks like a problem with C++14/C++1z: https://wandbox.org/permlink/y9HKOmw1fX68fJJL and https://wandbox.org/permlink/XprcAQRIJUpawUYx
There is a workaround for that problem in clang c++1z https://bugs.llvm.org/show_bug.cgi?id=28337#c3
Instead of getting it as error message
The problem with that is that you have to include
iostream, compile and run the program to see what T is. still a neat trick