The class ti(ostream) supports both formatted and emi(binary output).

The emi(insertion operator) (lshift()) is used to insert values in
a type safe way into tt(ostream) objects.  This is called
    i(formatted output), as binary values which are stored in the computer's
memory are converted to human-readable i(ASCII) characters according to
certain formatting rules.

The insertion operator points to the tt(ostream) object to
receive the information.  The normal associativity of lshift()
remains unaltered, so when a statement like
        verb(    cout << "hello " << "world";)

is encountered, the leftmost two operands are evaluated first (tt(cout)
lshift() tt("hello ")), and an tt(ostream &) object, which is actually the
same tt(cout) object, is returned. Now, the statement is reduced to
        verb(    cout << "world";)

and the second string is inserted into tt(cout).

The lshift() operator has a lot of (overloaded) variants, so many types of
variables can be inserted into tt(ostream) objects. There is an overloaded
lshift()-operator expecting an tt(int), a tt(double), a pointer, etc. etc..
Each operator returns the tt(ostream) object into which the information so far
has been inserted, and can thus immediately be followed by the next insertion.

    In addition to insertion operators tt(ostreams) also support
tt(std::print)hi(print). It is called as
 verb(     std::ostream& os, std::format_string<Args...> fmt, Args&&... args))
    where tt(...) indicates that any number of arguments can be specified.
However, since a tt(print)-like functionality is hardly ever required in
bf(C++) programs it's not covered in detail in the annotations(). Refer to
tt(cppreference.com) for details about tt(std::print).

    When hi(binary file) binary files must be written, normally no
text-formatting is used or required: an tt(int) value should be written as a
series of raw bytes, not as a series of i(ASCII) numeric characters 0 to
9. The following member functions of tt(ostream) objects may be used to
write `binary files':
    itemization(
    ithtq(put)(ostream& put(char c))
        (to write a single character to the output stream. Since a character
is a byte, this member function could also be used for writing a single
character to a text-file.)
     ithtq(write)(ostream& write(char const *buffer, int length))
        (to write at most tt(length) bytes, stored in the tt(char const
*buffer) to the tt(ostream) object. Bytes are written as they are stored
in the buffer, no formatting is done whatsoever. Note that the first argument
is a tt(char const *): a em(type cast) is required to write any other
type. For example, to write an tt(int) as an unformatted series of
byte-values use:
        verb(int x;
out.write(reinterpret_cast<char const *>(&x), sizeof(int));)

)
    The bytes written by the above tt(write) call are written to the
tt(ostream) in an order depending on the emi(endian)em(-ness) of the
underlying hardware. Big-endian computers write the most significant byte(s)
of multi-byte values first, little-endian computers first write the least
significant byte(s).
    )
