playground | Play with neural networks | Machine Learning library

because you want

t = append(t, 0)

the data type can be int or float group.

this code should work

Edit: see blackgreen's answer, which I also found later on my own while scanning through the same documentation they linked. I was going to edit this answer to update based on that, but now I don't have to. :-)

There is probably a better way—this one seems a bit clumsy—but I was able to work around this with reflect:

I've the same issue. If I launch Xcode using rosetta, it doesn't show anything. You must switch off rosetta and it works perfect.

UPDATE

Apparently, there is a reference to that, in a github issue - rust-lang/rust#63104:

This conflicts with the existing blanket impl in core.

With --strictFunctionTypes enabled, function types' parameters are checked contravariantly, as required to maintain type safety:

You have await inside async function. This works roughly as follows:

• Execute code line by line until await keyword
• Pause execution of this code block
• Once awaited value resolved continue until next await keyword

In your case, it iterates 20 times, then pauses everything once you hit a limit. Then, once at least one promise inside ret resolved it proceeds.

Next thing that is happening is that once any of the promises resolved, removes itself from array. But since almost everything happens instantaneously, you see that it - resolves all 20 promises, fills with another 20. If you make your iteratorFn slower with random delays, you'll see, that pool is constantly filling up to 20 and then almost immediately replaces freed space in pool with new promise, while there is at least some elements left.

Let's replace your iteratorFn with this and call it:

I don't have a complete citation of the reference manual for all the parts here, but the difference I see between these two cases is ClonableIterator is not visible in mod helper (there is no use super::ClonableIterator). Thus, the trait is not consulted for arbitrary types when looking up methods, but (evidently) it is for dyn super::ClonableIterator, presumably because it would be gratuitously unhelpful to not do that.

So the method lookup procedure will be doing approximately this:

1. We start with *self, an explicit dereference of &Box> of type Box>.
   • Does this have an inherent method named box_clone()? No.
   • Does any visible trait have a method named box_clone()?
     • In the first program, yes (ClonableIterator was declared in the same scope), so that one is called.
     • In the second program, no, so continue.
2. Dereference Box> to obtain dyn CloneableIterator<'a>.
   • Does this have an inherent method named box_clone()? No.
   • Does any visible trait have a method named box_clone()? Yes, apparently CloneableIterator is visible for the dyn type unconditionally.

My approach here would look like this: