A scenario like

  template<typename... Opts>
  constexpr auto validate(rbr::settings<Opts...> const& env) const
  {
    std::size_t sz = 1;
    ((sz = std::max(sz, size(env[typename Opts::keyword_type{}]))),...);
    using out_t = std::common_type_t<typename value_type<typename Opts::stored_value_type>::type...>;

    assert(   (is_valid(env[typename Opts::keyword_type{}], sz) && ...)
          &&  "Size mismatch in vector parameters"
          );
  }

happens a lot. Having a rbr::keywords<Settings> and a rbr::values<Settings> traits would be nice

If we just inherits from any_weyword to simply make a new keyword, opts[ kw | v ] doesn't work because it erases the type of kw to any_keyword.

We need a as_keyword struct to serve as a proper base class for custom keyword.
Kiwaku as a local implementation for this

There are situations where I need to ignore certain parameters when passing them along.

jfalcou/eve#880

Can we add it?

auto tr1 = drop_key(tr, key);

See : https://godbolt.org/z/jvv5K3q45

Fix:

  namespace literal
  {
    template<std::size_t N> struct str_
    {
      std::array<char,N> data;

      template <std::size_t... Is>
      constexpr str_(const char (&str)[N], std::index_sequence<Is...>) :data{str[Is]...} {}
      constexpr str_(const char (&str)[N]) : str_{str, std::make_index_sequence<N>{}} {}

                        std::string value() const { return std::string(&data[0],strlen(&data[0])); }
      static constexpr  auto        size()        { return N; }
    };

    template<std::size_t N> str_(const char (&str)[N]) -> str_<N>;
  }

  template<literal::str_ ID> struct id_
  {
    friend std::ostream& operator<<(std::ostream& os, id_ const& id)
    {
      return os << '\'' << id.value() << '\'';
    }
  };

I don't currently see a great way to pass a reference using a named keyword. When I use a reference typed keyword I get compilation errors, and if I use an untyped keyword and use std::ref it just copies the ref without decay. I feel like I should be able to use a reference typed keyword successfully, and I also feel like there is a small argument for implicit decay for reference_wrappers in both typed and untyped settings (like tuple).

Now that we have the rbr::keyword_parameter we can write code that takes rbr::keyword_parameter auto [const&,&&]... params. These are normally collected via rbr::settings and extracted using the keyword value. There are cases, like initializer lists, where this is a little bit inconvenient though, due mainly to its verbosity.

inline constexpr auto foo_keyword = ...;
constexpr Foo(rbr::keyword_parameter auto... params)
      : foo(rbr::settings{params...}[ foo_keyword | 0])])
      ...

In such cases it would be great to extend the rbr::keyword class with an operator()([T], rbr::keyword_parameter auto...) that can directly extract its value from a pack (possibly with the default option T).

inline constexpr auto foo_keyword = ...;
constexpr Foo(rbr::keyword_parameter auto... params)
     : foo(foo_keyword(0, ..., params))
     ...

If there is some meta-magic that allows the default to be provided as the last argument that would be even more amazing.