Ideas / Things Made

[robertshepherdcpp]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[robertshepherdcpp]

https://www.godbolt.org/z/18M7T9zhs

[robertshepherdcpp]

So we need to implement tuple_cat.hpp and tuple_reverse.hpp, a tuple_reverse that actually reverses the elements inside the tuple and the values: everything.

[robertshepherdcpp]

tuple_reverse is already implemented. Could implement tuple_cat soon.

[robertshepherdcpp]

I could also add something like this godbolt, where we have a bit of reflection. But bear in mind that this link does not work!

[robertshepherdcpp]

godbolt

[robertshepherdcpp]

add refl_get.hpp to the library from the link above: godbolt

[robertshepherdcpp]

godbolt

[robertshepherdcpp]

godbolt finished version

[robertshepherdcpp]

godbolt

[robertshepherdcpp]

inline if
non recursive while(don't think it is possible)

[robertshepherdcpp]

https://www.godbolt.org/z/GYxbGoKh1, godbolt is where i currently am at.

[robertshepherdcpp]

make this change to mlib::any_of: godbolt

[robertshepherdcpp]

godbolt

[robertshepherdcpp]

https://godbolt.org/z/8r5EnK6cx

[robertshepherdcpp]

godbolt

[robertshepherdcpp]

finished and draft

[robertshepherdcpp]

Ideas: Meta_struct that has a secret variable num_members using sizeof...(Ts).

[robertshepherdcpp]

godbolt

[robertshepherdcpp]

Add these short two lines of code to constexpr_map.hpp:

template<auto T>
static constexpr auto c_p = constexpr_parameter<T>{};

godbolt

[robertshepherdcpp]

Add this compile time switch statement: godbolt. Here is an example use case

    constexpr_switch<5, [](case_<0>) {std::cout << "it is 0\n";},
                        [](case_<5>) {std::cout << "it is not 0\n";},
                        [](auto)     {std::cout << "I don't know what it is!\n";}
                                              > value{};
    value();

[robertshepherdcpp]

https://www.godbolt.org/z/db8hzKzWd
https://www.godbolt.org/z/zPcEz68jo
https://godbolt.org/z/MPhnM4s1z
https://godbolt.org/z/8W3179cjj

[robertshepherdcpp]

godbolt compile-time parsing

[robertshepherdcpp]

version without errors

[robertshepherdcpp]

Add this value_range here:

// constexpr ranges

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

template<auto I>
constexpr auto get_nth_element(auto... Ts)
{
    return [&]<std::size_t... indexes>(std::index_sequence<indexes...>)
    {
        return [&](decltype((void*)indexes)... DontCare, auto* arg, auto *... DontCareEither)
        {
            return *arg;
        }(&Ts...);
    }(std::make_index_sequence<I>{});
}

namespace mlib
{
template<auto... Ts>
struct value_range
{
    constexpr auto operator|(auto lambda) const
    {
        return for_each<lambda>();
    }

    template<auto lambda>
    constexpr auto for_each() const
    {
        return value_range<lambda(Ts)...>{};
    }
    
    template<auto I>
    constexpr auto at() const
    {
        return std::get<I>(tuple());
    }

    constexpr auto tuple() const
    {
        return std::make_tuple(Ts...);
    }
};
} // namespace mlib

int main()
{
    mlib::value_range<1, 2, 3, 4> v{};
    constexpr auto x = v | [](auto x) constexpr {return x * x;}
                         | [](auto x) constexpr {return x + 4;}
                         | [](auto x) constexpr {return x / 2;}
                         | [](auto x) constexpr {return x * 256;}
                         | [](auto x) constexpr {return x / 2;};

      std::cout << x.at<2>();
}

[robertshepherdcpp]

https://www.godbolt.org/z/fnMK66vWG

[robertshepherdcpp]

https://www.godbolt.org/z/rbrnnsbzM

[robertshepherdcpp]

https://www.godbolt.org/z/8seEK7M6W

[robertshepherdcpp]

https://www.godbolt.org/z/8h9afs1fa

[robertshepherdcpp]

https://www.godbolt.org/z/Gv8rfrfh9

[robertshepherdcpp]

for_each_index, https://www.godbolt.org/z/z5za7beT5

[robertshepherdcpp]

https://www.godbolt.org/z/797Gdrcjr

[robertshepherdcpp]

https://godbolt.org/z/doozTbKr5

[robertshepherdcpp]

https://godbolt.org/z/8K31aTe69

[robertshepherdcpp]

https://godbolt.org/z/M6YdjxTMW

[robertshepherdcpp]

add these functions to string_parse:

        template<char c>
        constexpr auto all_characters_are() const noexcept
        {
            return [&]<std::size_t... indexes>(std::index_sequence<indexes...>)
            {
                return ((c == str.template nth_element<indexes>()) && ...);
            }(std::make_index_sequence<str.size()>{});
        }
        
        template<char c>
        constexpr auto all_characters_are_not() const noexcept
        {
            return [&]<std::size_t... indexes>(std::index_sequence<indexes...>)
            {
                return ((c != str.template nth_element<indexes>()) && ...);  
            }(std::make_index_sequence<str.size()>{});
        }

the godbolt link

[robertshepherdcpp]

// github.com/robertshepherdcpp/mlib

#include <utility>  // std::index_sequence
#include <tuple>    // std::tuple
#include <cstddef>  // std::size_t

namespace index_sequence {
    template <auto... Vs>
    constexpr auto apply(auto lambda, std::index_sequence<Vs...>) 
                        -> decltype(lambda.template operator()<Vs...>())
    {
        return lambda.template operator()<Vs...>();
    }
}  // namespace index_sequence

template<auto... Vs>
constexpr auto transform(auto lambda)
                        -> decltype(auto)
{
    return [&]<std::size_t... indexes>(std::index_sequence<indexes...>)
    {
        return std::tuple{(lambda(Vs))...};
    }(std::make_index_sequence<sizeof...(Vs)>{});
}

int main()
{
    index_sequence::apply(
      []<auto... Vs>() {return transform<Vs...>([](auto x)constexpr{return x + 1;});},
      std::make_index_sequence<5>()
      );
}

godbolt link

[robertshepherdcpp]

I made a constexpr iota, here is the godbolt link godbolt and here is the code:

// iota for the mlib library
#include<tuple>
#include<cstddef>
#include<utility>
#include<iostream>

template<auto lambda, typename... Ts>
constexpr auto for_each(std::tuple<Ts...> t)
{
	[=] <std::size_t... indexes>(std::index_sequence<indexes...>)
	{
		(lambda(std::get<indexes>(t)), ...);
	}(std::make_index_sequence<sizeof...(Ts)>{});
}

template<auto until>
constexpr auto iota()
{
    return []<std::size_t... indexes>(std::index_sequence<indexes...>)
    {
        return std::make_tuple(indexes...);
    }(std::make_index_sequence<until>{});
}

int main()
{
    constexpr std::tuple iota_vec = iota<10>();
    for_each<[](auto x){std::cout << x << " ";}>(iota_vec);
}