C>nread = my_read(...)
C>if (nread == -1)
C>    throw;
C>my_copy(src, dst, nread);
C>

nread = my_read(...)
if (nread <= -1)
    throw;
my_copy(src, dst, nread);

unsgined nread = my_read(...)
if (nread >= 0)
    my_copy(src, dst, nread)
throw io_error(nread);

int fn(fn_output_t *output,fn_input_t *input); // 0-нет ошибок, не 0 код ошибки

int my_read2(void *ctx,void *buffer,int size,int *readed) {
  int rd=my_read(ctx,buffer,size);
  if (readed) *readed=rd;
  return rd<0 ? rd : 0;
}

{
  int rc=0;
  ...
  int buf_size;
  if (my_read2(stream,buf,buf_lim,&buf_size)) { rc=my_error_read_problem; goto leave; }
  ...
leave:
  if (stream) my_close(stream);
  ...
  return rc;
}

struct my_read_result_t {
    my_read_result_t(int count) : value(count) {}
    int count() const { 
        if (invalid()) throw this;
        return value;
    }
    bool invalid() const { return value<0; }
private:
    int value;
};
my_read_result_t my_read(...) { ... }

std::tuple<bool,int> my_:read(...);

struct Stream {
  ...
  int read(void* data,int size);
  bool error();
  int get_error_code();
};
...
  int rd=stream->read(count);
  if (stream->error()) {
    code=stream->get_error_code();
...

int my_read(void *ctx,int count);
bool my_read_result_invalid(int res);

...
int rd=my_read(stream,count);
if (my_read_result_invalid(rd)) { panic(); }
...

M>>for(auto i=0u; i!=v.size(); ++i)
M>>

for (auto i = v.size(); i --> 0;)

TB>for i in 0 .. v.len()-1
TB>

for i in 0 .. v.len()

for i in 0 ..= v.len() - 1

for i in 0 ..= v.len() as i8 - 1

let v: Vec<u8> = Vec::new();
let sum: usize = (0..v.len() - 1).sum();

(0..-1).sum() // 0

M>>for(auto i=0u; i!=v.size(); ++i)
M>>

for(auto i = v.size()-1; i != -1; --i)
...

7.4 Usual arithmetic conversions
Many binary operators that expect operands of arithmetic or enumeration type cause conversions and yield
result types in a similar way.
...
— Otherwise, the integral promotions (7.3.6) shall be performed on both operands.56 Then the following rules shall be applied to the promoted operands:
...
(1.5.3) — Otherwise, if the operand that has unsigned integer type has rank greater than or equal to the
rank of the type of the other operand, the operand with signed integer type shall be converted to
the type of the operand with unsigned integer type.

An unsigned integer type has the same width N as the corresponding signed integer type. The range of representable values for the unsigned type is 0 to 2^N − 1 (inclusive); arithmetic for the unsigned type is performed modulo 2^N.

Given an integer n > 1, called a modulus, two integers a and b are said to be congruent modulo n, if n is a divisor of their difference (i.e., if there is an integer k such that a − b = kn).