I am playing around with trying to implement the numeric literal operator template.

```
#include <string_view>
#include <cstdint>
#include <cmath>
#include <iostream>
#include <boost/mp11/integer_sequence.hpp>
#include <boost/mp11/algorithm.hpp>
using namespace boost::mp11;

template <char... Cs>
[[nodiscard]] constexpr auto operator""_c(){
    int weight =std::pow(10, sizeof... (Cs));
    // unused, would like to transform it using lambda that mutably captures
    // weight
    using ints = index_sequence<sizeof... (Cs)>; 
    // ugly fold way
    auto val = ((weight/=10,(int)(Cs-'0')*weight) + ...);
    return val;
}

int main(){
    std::cout << 0_c  << std::endl;
    std::cout << 00_c << std::endl;
    std::cout << 01_c << std::endl;
    std::cout << 123_c << std::endl;
}

```

This [code](https://godbolt.org/z/foaGb9ooo) works for simple cases(correctness is not important, e.g. negative numbers), it is just an example, but code looks ugly and clang emits a warning for modifying weight multiple times, so I guess code is buggy(undefined or unspecified behavior) although it seems to work...

Now I wonder is there a way for me to transform the `ints` I use(it is from boost::mp11, but same thing exists in std::) with a stateful lambda (that modifies weight).
So I would like to transfer ints, that are `<0,1,2>` into something like `<100,10,1>`

I presume this has been asked before but this is very hard to search for.

To be clear: operator "" is just a toy problem, my real question is about mapping the values of integer sequence with a stateful lambda.

Also if not clear from question: I am perfectly happy to use boost mp11, but could not find anything in the docs.