Things To Add to the library

[robertshepherdcpp]

To add a new thing, first float the idea here, with an explanation on why it should be here!

🎉: Will get put in the mlib library!
💕: Has been put in, great feature!
👍: Looking Good!
🚀: Being put in now!
👎: No sorry, I don't think it would be suitable.

[robertshepherdcpp]

mlib::amount, is a new feature that will allow code like this, godbolt:

int main()
{
    std::string s{};
    mlib::amount_t<10>.times([&](){s += "a";});
    std::cout << s << "\n"; // outputs: aaaaaaaaaa
}

This will be very useful and it is all happening at compile time, as after all this is a metaprogramming library! You could also do it with constexpr_while but this method is more clean and concise.

Here is the implementation, it doesn't need to use the std, it is relatively quick, but it does use recursion, so can be really slow when there is 500 recursions. To actually do the recursion you need to use the .times(auto&& lambda) mmber function. So here is the implementation:

namespace mlib
{
    template<auto T>
    struct amount
    {
        constexpr auto times(auto&& lambda) const;
    };

    template<auto T>
    static constexpr auto amount_t = amount<T>{};

    template<auto T>
    constexpr auto amount<T>::times(auto&& lambda) const
    {
        lambda();
        if constexpr(T - 1 != 0)
        {
            amount_t<T - 1>.times(lambda);
        }
        return true;
    }
}; // namespace mlib

An easy way to use it, as shown in the first code snippet is just to use:

amount_t<NUM_OF_RECURSIONS>.times([](){});

[robertshepherdcpp]

Added in: b6a7ada! 💕

[robertshepherdcpp]

mlib::get_nth_element will be a new feature and will allow code like this: godbolt:

int main()
{
  mlib::get_nth_element<N>(42, 'c', 3.14, true); // will return the Nth element of the args passed in.

  mlib::get_nth_element<2>(42, 'c', 3.14, true); // returns 3.14
}

This will be useful because 1. It is very fast, is doesn't use recursion it instead just uses the tequnice Imeadiatley Invoked Lambdas. It is relatively simple, and it very easy to use pass the element you want to find, N in a template parameter: mlib::get_nth_element<N> and then the list of args args.... Bear in mind that this function happens at compile time as it has the constexpr keyword applied to it. This is a meta-programming library after all!

The function mlib::get_nth_element is relatively easy to implement, you can find it on godbolt which also has a bit more detail on the matter, here is the implementation of mlib::get_nth_element:

namespace mlib {
template <auto N> constexpr auto get_nth_element(auto... args) {
    return [&]<std::size_t... Indexes>(std::index_sequence<Indexes...>) {
        return [](decltype((void *)Indexes)... DontCare, auto *arg,
                  auto *...DontCareEither) { return *arg; }(&args...);
    }(std::make_index_sequence<N>{});
}
} // namespace mlib

[robertshepherdcpp]

Added in 4d34a2a! 💕

[robertshepherdcpp]

mlib::inline_if will be a new feature that will be very useful for doing things simply on one line, godbolt. Here is a simple example of using it:

struct s {
    static constexpr auto x = inline_if<char, SameAs, bool, 42, 'c'>{}();
};

int main() { std::cout << s{}.x; }

Note that SameAs is provided in the mlib namespace. But there will be future support for providing lambdas in place of mlib::SameAs. An example implementation of mlib::inline_if is as follows:

namespace mlib
{
struct SameAs {};

// this is a bad implementation, becuase it requires operator==
template <typename A, typename B> struct is_same {
    static constexpr bool value = false;
};

template <typename A, typename B>
    requires(A{} == B{})
struct is_same<A, B> {
    static constexpr bool value = true;
};

template <typename T, typename condition, typename ToCompare, auto first_,
          auto second_>
struct inline_if {
    constexpr inline_if() {}

    constexpr auto get() {
        }
    constexpr auto operator()() { return get(); }

    static constexpr auto first = first_;
    static constexpr auto second = second_;
    };

template<typename condition, typename ToCompare, auto first_, auto second_>
struct inline_if<is_same, condition, ToCompare, first_, second_>
{
    constexpr inline_if() {}

    constexpr auto get() {
        if constexpr (is_same<T, ToCompare>::value) {
            return first;
        } else if constexpr (!is_same<T, ToCompare>::value) {
            return second;
        }
    constexpr auto operator()() { return get(); }

    static constexpr auto first = first_;
    static constexpr auto second = second_;
};
} // namespace mlib

So, it is very to use, just providing 5 template parameters, initializing the object: {} and then calling operator() in order to get the value. But do bear in mind that it needs some refinments first.

[robertshepherdcpp]

Added in 4eacaf3! 💕

[robertshepherdcpp]

value_pack will be a new feature that allows handling of parameter packs, ... to be easier. I allows you to use member functions like begin(), end(), operator[], get<>() and much more, an example use case is as follows godbolt:

template <auto... Ts> auto function(mlib::value_pack<Ts...> &pack_) {
    return pack_.begin();
}

template <auto... Ts> auto function_two(mlib::value_pack<Ts...> pack_) {
    static_assert(pack_.size() > 3);
    return pack_[mlib::index<2>{}];
}

int main() {
    std::cout << function_two(mlib::value_pack<'c', true, 42, 3.142>{});
}

It is just a wrapper around a pack, which allows things to do with parameter packs, ... very easy to use. The only burden is having to do mlib::value_pack<'c', true, 42, 3.142>{} but you could always make a helper function, to help with this:

template<auto... Ts>
static constexpr mlib::value_pack<Ts...> v_p = mlib::value_pack<Ts...>{};

So then it would all be really easy to use. The implementation looks as follows: godbolt:

// pack.hpp

#include <cstddef>
#include <iostream>
#include <utility>

#include"get_nth_element.hpp"

namespace mlib {

template <auto I> struct index {};

template <auto... Ts> struct value_pack {

    static constexpr auto begin_value = mlib::get_nth_element<0>(Ts...);
    static constexpr auto end_value =
        mlib::get_nth_element<sizeof...(Ts) - 1>(Ts...);
    static constexpr auto size_value = sizeof...(Ts) - 1;

    constexpr auto size() { return (sizeof(Ts) + ... + 0); }

    constexpr auto begin() { return begin_value; }
    constexpr auto end() { return end_value; };

    template <auto I> constexpr auto operator[](index<I>) {
        return mlib::get_nth_element<I>(Ts...);
    }

    template <auto I> constexpr auto get() {
        return mlib::get_nth_element<I>(Ts...);
    }

    value_pack() { /*Does Nothing!*/}
};
} // namespace mlib

So, it is very simple to use, just pass in your parameter pack and then use it like an object!

[robertshepherdcpp]

Added in 534b46c! 💕

[robertshepherdcpp]

mlib::integral_constant will be a very short, but very useful thing for things to happen at compile time. Because in this library I want to gradually and gradually not have to use the std library. An example implementation of mlib::integral_constant is as follows godbolt:

namespace mlib
{
    template <typename T, T I> struct integral_constant {
        static constexpr T value = I;
        using value_type = T;

        constexpr operator value_type() const noexcept { return value; }

        constexpr auto operator()() const noexcept { return value; }
    };
} // namespace mlib

[robertshepherdcpp]

Added in 7adc91b! 💕