Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • Jan 31 2019 15:06

    ldionne on gh-pages

    Update benchmarks to 490dbf6 fo… (compare)

  • Jan 24 2019 07:47

    ldionne on gh-pages

    Update benchmarks to 490dbf6 fo… (compare)

  • Jan 23 2019 02:04
    pthom commented #432
  • Jan 18 2019 12:46

    ldionne on gh-pages

    Update benchmarks to 490dbf6 fo… (compare)

  • Jan 16 2019 22:27
    ricejasonf commented #434
  • Jan 05 2019 06:22
    ricejasonf commented #330
  • Jan 03 2019 11:40

    ldionne on gh-pages

    Update benchmarks to 490dbf6 fo… (compare)

  • Jan 02 2019 00:33
    ricejasonf closed #434
  • Jan 02 2019 00:33
    ricejasonf commented #434
  • Jan 02 2019 00:04
    ricejasonf opened #434
  • Dec 27 2018 13:11

    ldionne on gh-pages

    Update benchmarks to 490dbf6 fo… (compare)

  • Dec 22 2018 11:56
    pthom commented #432
  • Dec 22 2018 11:55
    pthom commented #432
  • Dec 21 2018 15:48
    pthom synchronize #432
  • Dec 21 2018 09:19
    sdebionne opened #433
  • Dec 21 2018 00:08
    ricejasonf commented #432
  • Dec 21 2018 00:03
    ricejasonf commented #432
  • Dec 20 2018 23:36
    pthom commented #432
  • Dec 20 2018 23:36
    pthom commented #432
  • Dec 20 2018 23:13
    ricejasonf commented #432
Barrett Adair
@badair
I agree. I see that there is "group" in hana, but it looks like it excludes the predicate result from the group result
Jason Rice
@ricejasonf
I'm certain a PR for that would be welcome.
Barrett Adair
@badair
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();
}
Louis Dionne
@ldionne
Jason Rice
@ricejasonf
There is a workaround for that problem in clang c++1z https://bugs.llvm.org/show_bug.cgi?id=28337#c3
Louis Dionne
@ldionne
Ah, thanks for the heads up.
Shreyans
@shreyans800755

@badair You can print the type of complex templated data type using the following:

template<typename T>
void print_T() { std::cout << __PRETTY_FUNCTION__ << '\n'; }
print_T(decltype(grouped));

FYI

Instead of getting it as error message
Jason Rice
@ricejasonf
I had no idea you could do that. Your print_T has to take a T as an argument though.
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
Barrett Adair
@badair

So, what is the best way to transform this:

hana::tuple<
    hana::pair<A, B>,
    hana::pair<A, C>,
    hana::pair<B, C>,
    hana::pair<A, D>,
    hana::pair<B, D>>

into something like this:

hana::tuple< /*map*/
    hana::pair<A, hana::tuple<B, C, D>>,
    hana::pair<B, hana::tuple<C, D>>>
I'm playing around with monadic_fold_left
Jason Rice
@ricejasonf
Is using monadic_fold_left a requirement?
Barrett Adair
@badair
nope
I have a compile-time list of pairs that I want to transform/flatten into a map of first -> tuple<second...> if that makes sense
I'm exploring some ideas for a compile-time graph
Jason Rice
@ricejasonf
I think sort then group would be good unless there are only two keys then partition would be better
Barrett Adair
@badair
okay thanks
what if the types don't have an ordering though
Jason Rice
@ricejasonf
oh yeah :sweat_smile:
You could even use fold_left but it will be very slow
I'll take a hack at it later
Barrett Adair
@badair
I did it with fold_left like this
but it's probably a slow way to do it
Louis Dionne
@ldionne
@badair @ricejasonf For info, I’m trying to fix C++1z issues: boostorg/hana#361
Jason Rice
@ricejasonf
Sweet!
Barrett Adair
@badair
Is there a customization point for Hashable in the same way that you can define equal to satisfy Comparable?
Jason Rice
@ricejasonf
hana::hash_impl
Do you really need that?
Barrett Adair
@badair
is that part of the stable interface?
Jason Rice
@ricejasonf
yes
Barrett Adair
@badair
Yes I do
Barrett Adair
@badair
I don't see hash_impl in the documentation -- how do you customize it for your own type?
Jason Rice
@ricejasonf
watch my video :P
you specialize hash_impl for your datatype's tag
the public facing function is just hana::hash
Barrett Adair
@badair
I already did! Don't remember that part. Okay thanks
Jason Rice
@ricejasonf
I'm really curious about the use case you have for it
Barrett Adair
@badair
Let me back up then. Is there a type in Hana that's like hana::type but lets you store a value of that type inside? I didn't find one so I made one myself.
Jason Rice
@ricejasonf
Wouldn't that be just an instance of the value of that type?
Barrett Adair
@badair
Yeah. Does hana::type<T> have a member of type T?
bc that's what I need
Jason Rice
@ricejasonf
using Foo = typename my_type::type;
Do your As and Bs have run-time state?
Barrett Adair
@badair
yes
which is what makes Hana so perfect for my use case
Barrett Adair
@badair
this is what I ended up doing:
// todo this shouldn't be necessary
template<typename T>
struct type_v {
    T value;

    template<typename U>
    constexpr auto equal(U) const {
        return std::is_same<T, U>{};   
    }
};
Jason Rice
@ricejasonf
If it was me I would do hana::pair<hana::type<T>, hana::pair<T, V>>
Barrett Adair
@badair
I did that too