flat_map | A compact map stored as a vector of key , value pairs | Map library

brew install ./cmake.rb will try to install a bottle, which obviously doesn't exist anymore. Try installing from source with brew install -s ./cmake.rb.

flat_map() is the wrong tool for this task. It is designed to flatten an iterator of iterators, i.e. whenever it encounters None on an inner iterator, its job is to switch to the next iterator. If you keep feeding it empty iterators, it will keep looping until it finds a non-empty one to deliver values from. flat_map() will only terminate iteration when the outer iterator does, which in your case never happens.

What you need is two things: first, mark the end of iteration in some way other than an empty iterator - e.g. by using an Option where Some means "here is another iterator for you" and None means "I'm no longer interested in iteration, you can terminate". Second, you need to terminate the iteration before the flattening step, using an adapter with the capacity to do so, such as take_while() or scan().

Here is a modification of your code that terminates after i reaches 10:

Unfortunately, what you are trying to do is not really possible in Rust right now. Not by design, but simply because some relevant type level features are not implemented or stabilized yet.

Unless you have spare time, an interest in type level stuff and are willing to use nightly: just use boxed iterators. They are simple, they just work, and in most cases it will likely not even hurt performance in a meaningful way.

You're still reading? Ok let's talk about it.

As you intuitively tried, impl Trait in return type position would be the obvious solution here. But as you noticed, it doesn't work: error[E0562]: `impl Trait` not allowed outside of function and inherent method return types. Why is that? RFC 1522 says:

Initial limitations:

impl Trait may only be written within the return type of a freestanding or inherent-impl function, not in trait definitions [...] Eventually, we will want to allow the feature to be used within traits [...]

These initial limitations were put in place because the type level machinery to make this work was/is not in place yet:

One important usecase of abstract return types is to use them in trait methods.

However, there is an issue with this, namely that in combinations with generic trait methods, they are effectively equivalent to higher kinded types. Which is an issue because Rust's HKT story is not yet figured out, so any "accidental implementation" might cause unintended fallout.

The following explanation in the RFC is also worth reading.

That said, some uses of impl Trait in traits can be achieved already today: with associated types! Consider this:

prefetch allows later elements to be prepared while the current element is being processed. This often improves latency and throughput at the cost of using additional memory to store prefetched elements.

Where as batch is combines consecutive elements of dataset into batches based on batch_size.

It has no concept of examples vs. batches. examples.prefetch(2) will prefetch two elements (2 examples), while examples.batch(20).prefetch(2) will prefetch 2 elements (2 batches, of 20 examples each).

For more details you can refer methods of tf.data.Dataset.

The following works:

That's easy. Do this in your split function

What you want is not to adopt the memory resource - because you can and do - but to also store the vector itself there.

You can, e.g. using a helper to create unique_ptr's with custom deleters:

In your outer match, the compiler can infer that both branches should be coerced to Box because of the return type. But that inference doesn't bubble up into the nested match since flat_map is generic over the inner iterator type.

To fix that, you can either annotate the first branch of the match, or create a temporary variable with the expected type: