boostorg/hana

Your standard library for metaprogramming

Maik Klein

@MaikKlein

Thanks, is there are reason why this index_offunction is not in hana?

Louis Dionne

@ldionne

I guess one has to separate between core and non-core functionality. If I had to add every function that finds its use somewhere, the library would grow insanely huge.

There’s this, plus lack of time. Also, I’ll consider adding it if there’s a lot of people asking for it.

Maik Klein

@MaikKlein

okay, makes sense

Maik Klein

@MaikKlein

Why did you write

 auto size = decltype(hana::size(iterable)){};

instead of just

 auto size = hana::size(iterable));

Jason Rice

@ricejasonf

it is in the second comment

to ensure it is not evaluated at run-time. I would think assigning it to a constexpr would do the trick though.

Maik Klein

@MaikKlein

but this only applies to the drop_while right? Not the the first hana::size?

Louis Dionne

@ldionne

Technically, it could be incur a non-trivial runtime cost to compute the size of an iterable. The cost is trivial for hana::tuple, but not necessarily for some user-defined container.

Jason Rice

@ricejasonf

#include<boost/hana.hpp>

namespace hana = boost::hana;

auto rearrange = [](auto xs, auto spec) {
  auto type_map =  hana::unpack(
    hana::range_c<int, 0, hana::length(xs)>,
    [&](auto... i) {
      return hana::make_map(hana::make_pair(
        hana::decltype_(xs[i]), i)...);
    });
  return hana::unpack(spec,
    [&](auto... x) {
      return hana::make_tuple(xs[type_map[hana::decltype_(x)]]...);
    });
};

int main()
{
  BOOST_HANA_RUNTIME_ASSERT(
    rearrange(
      hana::make_tuple(1, 1.0f, 1.0),
      hana::tuple_t<double, int, float>)
    == hana::make_tuple(1.0, 1, 1.0f));
}

I'm guessing that no output means that it works.

Louis Dionne

@ldionne

Lol, yes.

This is good. If map lookup was implemented efficiently (which it will once I find some time), this would be O(N) compile-time.

That’s optimal.

Jason Rice

@ricejasonf

Louis Dionne

@ldionne

Although you should use perfect forwarding for xs. If xs is a temporary, you could move the values into the new tuple instead of making a copy. I guess that’s a detail. I’m out for now anyways, bye!

Jason Rice

@ricejasonf

gnight

Maik Klein

@MaikKlein

@ricejasonf that is a nice use case for range_c, thanks

Maik Klein

@MaikKlein

btw is it possible to avoid template instantiations after every compilation?

using expensive  = expensive_type<T0,T1....TN-1>;

...
int main(){
//change occurs here but expensive didn't change, does it need to be instantiated again?
}

Maik Klein

@MaikKlein

Seems like this could be "solved" with ccache?

Jason Rice

@ricejasonf

It looks like ccache works with individual compiliation units.

I once thought that clang was prohibitively slower than gcc, but then I realized I made it with a debug build type. :P

Jason Rice

@ricejasonf

So I've been trying to warm up to generating several permutations of arbitrarily structured 'messages' based on several tests applied to a spec. I decided to play around with making different implementations of the following psuedo code (from wikipedia :P):

function is_prime(n : integer)
    if n ≤ 1
        return false
    else if n ≤ 3
        return true
    else if n mod 2 = 0 or n mod 3 = 0
        return false
    let i ← 5
    while i×i ≤ n
        if n mod i = 0 or n mod (i + 2) = 0
            return false
        i ← i + 6
    return true

here is my first attempt with a bunch of nested if_s

#include<boost/hana.hpp>

namespace hana = boost::hana;

constexpr auto if_ = hana::if_;
template<int c>
constexpr auto int_c = hana::int_c<c>;
template<bool c>
constexpr auto bool_c = hana::bool_c<c>;

auto primality_test = [](auto n)
{
  return
    if_(n <= int_c<1>, hana::nothing,
      if_(n <= int_c<3>, hana::just(n),
        if_(n % int_c<2> == int_c<0> || n % int_c<3> == int_c<0>, hana::nothing,
          if_(hana::is_just(hana::while_(
            [&](auto just_i) {
              return hana::maybe(bool_c<false>,
                [&](auto i) {
                  return bool_c<i * i <= n>;
                }, just_i);
            },
            hana::just(int_c<5>),
            [&](auto just_i) {
              return hana::maybe(hana::nothing,
                [&](auto i) {
                  return if_(n % i == int_c<0> || n % (i + int_c<2>) == int_c<0>, hana::nothing,
                    hana::just(i + int_c<6>));
                }, just_i);
            })), hana::just(n), hana::nothing)))); //practically lisp!
};

int main()
{
  static_assert(decltype(primality_test(int_c<1009>)){} == hana::just(int_c<1009>), "");
  static_assert(decltype(primality_test(int_c<1010>)){} == hana::nothing, "");
}

Jason Rice

@ricejasonf

In my second go, I am working on chaining these conditions instead of nesting. I was going to try to avoid using while_, but it doesn't seem there is any other way without generating all of the possible i values up front in a range or something.

Is while_ the best choice here?

Jason Rice

@ricejasonf

https://gist.github.com/ricejasonf/5a249ea8ee0cb43f7bec

the second one is slighty slower

Jason Rice

@ricejasonf

oh crap wait

Jason Rice

@ricejasonf

the test was broken

Jason Rice

@ricejasonf

http://ldionne.com/2015/11/29/efficient-parameter-pack-indexing/
that's awesome

the builtin that is

Louis Dionne

@ldionne

@ricejasonf Yes, I think it’s quite nice. I just hope the Clang/libc++ guys will want the patch.

Regarding your primality testing example, here's how I would do it:

#include <boost/hana.hpp>
namespace hana = boost::hana;


constexpr bool is_prime_impl(int n) {
    if (n <= 1)
        return false;
    else if (n <= 3)
        return true;
    else if (n % 2 == 0 or n % 3 == 0)
        return false;

    int i = 5;
    while (i*i <= n) {
        if (n % i == 0 or n % (i + 2) == 0)
            return false;
        i += 6;
    }
    return true;
}

template <typename N>
constexpr auto is_prime(N const&) {
    return hana::bool_c<is_prime_impl(hana::value<N>())>;
}


auto primes = hana::tuple_c<int,
    2,  3,  5,  7, 11, 13, 17, 19, 23, 29,
    31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
    73, 79, 83, 89, 97,101,103,107,109,113,
    127,131,137,139,149,151,157,163,167,173,
    179,181,191,193,197,199,211,223,227,229,
    233,239,241,251,257,263,269,271,277,281,
    283,293,307,311,313,317,331,337,347,349,
    353,359,367,373,379,383,389,397,401,409,
    419,421,431,433,439,443,449,457,461,463,
    467,479,487,491,499
>;

int main() {
    auto integers = hana::make_range(hana::int_c<0>, hana::int_c<100>);
    hana::for_each(integers, [](auto i) {
        static_assert(decltype(hana::contains(primes, i) == is_prime(i)){}, "");
    });
}

For homogeneous problems, it's much easier and much faster to just use constexpr.

Note that hana::contains is quite slow (it could be optimized, at least for hana::types and hana::integral_constants, but it isn’t).

Jason Rice

@ricejasonf

ha ha.. i guess i was overcomplicating things

or rather it is a contrived use case

Maik Klein

@MaikKlein

How do you output different error messages?

Pseudo code:

constexpr auto size = hana::size(something);
// (size == 0) => print "Does not contain anything"
// (size > 1) =>print "Contains duplicates"

where "print" would be the compile time error.

Jason Rice

@ricejasonf

wouldn't static_assert work?

Maik Klein

@MaikKlein

I could do static_assert(hana::size(s) == hana::size_c<1>, "Something is wrong");

but then I wouldn't know if it i was 0 or bigger then one and checking that seems a bit cumbersome with static_assert

Jason Rice

@ricejasonf

static_assert(size == 0, "Does not contain anything");
static_assert(size > 1, "Contains duplicates");

This message was deleted

Maik Klein

@MaikKlein

hm okay I must be tired :d

Jason Rice

@ricejasonf

☕

Maik Klein

@MaikKlein

Wait it should work with 1, but should not accept 0 or 2+. size == 0 doesn't work because 1 == 0 will trigger the assert, and static_assert triggers at false not true.

size != 0 doesn't work because it will also trigger at 1+. I could solve this but it would require some boolean shenanigans

Jason Rice

@ricejasonf

ah right

Maik Klein

@MaikKlein

    static_assert(size != 0 || size >= 1, "Empty");
    static_assert(size == 1 || size == 0, "More than 1");

Should be what I want, but that seems way too complicated for something so simple

Where communities thrive

People

Repo info

Activity