iota | A simple IO library for using Clojure 's reducers | Dataset library

The reason why generate2 cannot work is that it does not model the range concept, that is, the type returned by its begin() does not model input_iterator, because input_iterator requires difference_type and value_type to exist and i++ is a valid expression.

In addition, your iterator does not satisfy sentinel_for, which means that it cannot serve as its own sentinel, because sentinel_for requires semiregular which requires default_initializable, so you also need to add default constructors for it.

You also need to rewrite bool operator!=(...) to bool operator==(...) const since operator!= does not reverse synthesize operator==. But it's easier to just use default_sentinel_t as sentinel in your case.

if you add them to iterator you will find the code will be well-formed:

1. Does this cause any problems? UB or otherwise? (seems fine to me?)

As long as the move assignment and the constructor are implemented in such a way that it does what you want, then I don't see a problem.

1. Is there a more idiomatic way?

I would invert the direction of re-use.

Why is the variable 'n' in 2nd usage of std::generate and within lambda capture not preceded with it's data type in below code?

It's not preceded with a data type, because the grammar of C++ says that it doesn't need to - nor even allowed to - be preceded by a type name.

A type name isn't needed because the type is deduced from the type of the initialiser expression.

The output you got does not signify that one node is disconnected.

The parent data structure represents links from one node to another (or itself, when it is a root).

At the start you have this:

And at the end we have this:

The important thing here is that there is one tree. It is not required that all nodes are linked directly to the root, just that they have a path to the root, which is also true for the node with index 3.

NB: if you would call find(3), then also index 3 would receive value 0. It is just something that gets optimised by calling find, but it doesn't change the meaning of result.

With the auto i you never use the variable anywhere.

With the for ( unsigned i=0; i < max_iter; i++ ) you're using i twice, once in i < max_iter and again in i++ so the variable is used

Is it possible for it to create something of a totally different type (not even weakly incrementable)? And can I safely ignore the warning?

According to the synopsis of iota_view in [range.iota.view]:

All the algorithms require copy-constructible function objects, and views are basically lazy algorithms.

Historically, when these adaptors were added, views were required to be copyable, so we required the function objects to be copy_constructible (we couldn't require copyable without ruling out captureful lambdas). The change to make view only require movable came later.

It is probably possible to relax the restriction, but it will need a paper and isn't really high priority.

For a fixed number like this, it would be possible to use metaprogramming to recursively build the range (although you might hit a template instantiation depth limit). You can do a truly dynamic number by type-erasing the ranges, such that the chain of filters is connected by virtual function calls. The result is slow and the code is painful, but it’s certainly possible.

The correspondence between go-logr and go.uber.org/zap log levels is given by: