how do you think of the tool reflex_map in creating interacting console app, here's the demo and the input/ouput in console:
```cpp
#include"exp_reflex.hpp"
#include"offset_poiner.hpp"
#include<string>
#include<print>
#include<vector>
using namespace std::literals;
class align8_demo {
    using test_40_align_type = std::string;
    using test_8_align_type = double;
    using test_4_align_type = int;
    using test_2_align_type = short;
    using test_1_align_type = char;
public:
    align8_demo() noexcept {}
    void record(std::string type_name, std::size_t s) {
        type_record.emplace_back(std::pair<std::string, std::size_t>(type_name, s));
    }
    void reset() {
        type_record.clear();
        off = 0;
        layer = 0;
    }
    void show() {
        std::size_t offset{ 0 };
        for (auto& x : type_record) {
            switch (x.second) {
            case 40:
                offset = offset_pointer::align_offset_seek<test_8_align_type, test_40_align_type>(layer, off);
                offset_pointer::align_offset_advance<test_8_align_type, test_40_align_type>(layer, off);
                break;
            case 8:
                offset = offset_pointer::align_offset_seek<test_8_align_type, test_8_align_type>(layer, off);
                offset_pointer::align_offset_advance<test_8_align_type, test_8_align_type>(layer, off);
                break;
            case 4:
                offset = offset_pointer::align_offset_seek<test_8_align_type, test_4_align_type>(layer, off);
                offset_pointer::align_offset_advance<test_8_align_type, test_4_align_type>(layer, off);
                break;
            case 2:
                offset = offset_pointer::align_offset_seek<test_8_align_type, test_2_align_type>(layer, off);
                offset_pointer::align_offset_advance<test_8_align_type, test_2_align_type>(layer, off);
                break;
            case 1:
                offset = offset_pointer::align_offset_seek<test_8_align_type, test_1_align_type>(layer, off);
                offset_pointer::align_offset_advance<test_8_align_type, test_1_align_type>(layer, off);
            }
            std::println("type: {}, offset: {}", x.first, offset);
            offset = 0;
        }
    }
    static auto reflex() {
        return exp_function_series::link_object{
            &align8_demo::record,
            &align8_demo::show,
            &align8_demo::reset
        };
    }
private:
    std::vector<std::pair<std::string, std::size_t>> type_record;
    std::size_t off{};
    std::size_t layer{};
};

int main() {
    align8_demo Ad{};
    exp_reflex::reflex_map rm{ align8_demo::reflex(), Ad };

    rm.reflex_as("record"s, "show"s, "reset"s);
    std::println("support size: 40, 8, 4, 2, 1 bytes, alignment in 8 bytes");
    std::println("usage: \n1. record [type] [size]\n2. show\n3. reset");
    auto ipt = exp_reflex::rm_input(rm);

    while (ipt()) {}
}
```
here's the input/output:
support size: 40, 8, 4, 2, 1 bytes, alignment in 8 bytes
usage:
1. record [type] [size]
2. show
3. reset
record int 4
record string 40
record double 8
record char 1
record char 1
show
type: int, offset: 0
type: string, offset: 8
type: double, offset: 48
type: char, offset: 56
type: char, offset: 57
reset
record int 4
record char 1
record double 8
show
type: int, offset: 0
type: char, offset: 4
type: double, offset: 8
exit