Templated byte streaming
Well, there are a few points:


You make a copy of the object you output. That can be costly, impossible, or have undesirable side-effects. Use a constant reference instead.
There are essentially two modes for your byte_streamer: Output the raw bytes, or output as decimal values for each byte.
The latter is broken as each byte is variable-width (1-3 digits for octets), and there is no separator.
You use the member placeholder only to convey the type outT to other code. Why not use a typedef instead, avoiding inefficiency and painful contortions?
Only use std::endl if you want to flush the stream. Otherwise, using '\n' and avoiding that extra-work is simply far more efficient.
It's really unusual not to end the programs output with a line-break. Wonder where the prompt will end up if called from a terminal...


Imho, the only useful outputs would be hex-dump and raw-bytes.

class dump_hex_t {
    const void* p = nullptr;
    std::size_t s = 0;
public:
    constexpr dump_hex_t() noexcept = default;
    constexpr dump_hex_t(const void* p, std::size_t s) noexcept : p(p), s(s) {}

    template &lt;class CharT, class Traits&gt;
    friend auto&amp; operator&lt;&lt;(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, dump_hex_t x) {
        ... // Dump as hex-digits however you like
    }
};

template &lt;class T&gt;
constexpr dump_hex_t dump_hex(const T&amp; x) noexcept
{ return { std::addressof(x), sizeof x }; }

template &lt;class T&gt;
constexpr std::string_view dump_raw(const T&amp; x) noexcept
{ return { (const char*)std::addressof(x), sizeof x }; }