deref | JSON-Schema ref resolution | JSON Processing library

My error with the component diappearing/reappearing turned out to be triggered by something else. A conflict/mismatch with popup-ids and a dispatch to clear one popup leading to destroying all of them.

But to answer the question, it works when you introduce a (fn []) block after the let binding where you actually do the subscription, and calling the components from inside the fn.

The issue is that you're mixing multithreading and async in a way which causes all the work to be sequential: all your threads do is call get_single_tweet which is apparently an async function.

Now in a language like Javascript, get_single_tweet would create a task, which would return a promise symbolising the realisation of the task and run as soon as possible.

That's not how Rust works (or lots of other languages, incidentially, Python behaves much more like Rust than it does Javascript). In Rust, get_single_tweet just creates a future, it doesn't actually do anything, the future has to be polled for things to happen: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=b26b47e62e46b66b60844aabc2ea7be1

When does this polling happens? When the dynamic chain of await-ing reaches the top of the event loop.

Here the future is created in the thread, then returned from the thread, then await-ed when fetched from the join, so your fetches are not being run in threads, they're being run here:

You need to clone it before it's moved. Otherwise your first iteration will necessarily need to take it (since there is no guarantee config will still exist to be cloned when the task runs). Then you get the error you see for the second iteration, since it too necessarily needs to move config; that's what it means by "value moved into closure here, in previous iteration of loop".

You haven't showed your DBACINEMA.TSET_REF_SEEN, so I can only guess that is a collection and you need to use one more table():

I think your code works fine (except for the while loop and global.gc(), of course). If you run this test page in Chrome, and you wait a while, eventually it logs in the console that many WeakRefs have indeed been garbage-collected: https://output.jsbin.com/momelej

Disclaimer: I haven't tried this code. But it is only here to give you an idea of the direction to go in.

Firstly, local variables (on the stack) in Rust must be fixed sized. This is one of the problems you are facing. Transaction and Connection aren't the same sized. So you can't achieve "Polymorphism" on the stack, without some tricks.

The two ways to do this are Enum types, and Boxing (putting the structs on the Heap, and adding a VTable).

I won't go over Boxing, since that is relatively simple.

The second problem you have is that Transaction's lifetime is tied to the Connection, so any moving of the Transaction will require you to move the Connection as well.

Deref is fine since your structure is specifically a vec with additional invariants (so making it usable as a vec seems sensible) but DerefMut seems like a rather bad idea as it will let the caller leak the internal Vec (as a mutable reference) and break your invariants.

One option might be to Deref to a slice (instead of a vec), in which case DerefMut will also get you a slice, which has pretty severe restrictions and thus won't be able to break your invariants. That will mean you may need to reimplement inherent Vec methods, and won't be able to pass off as a Vec, though.

An other option would be to not implement DerefMut at all, and have more explicit methods for these. Also WRT iterables, note that you only need to implement IntoIterator and other iterator-yielding methods (.iter(), .iter_mut()): the result can just be whatever iterator the underlying collection returns.

Now I don't know what you meant by

However, I was not sure which traits I should implement: are Iterator [...] enough?

You should not, under any circumstance, implement Iterator directly on your SizedVec. That is a terrible, terrible idea.

The iterator sub-traits are basically markers, they provide additional features over Iterator (but can't necessarily be implemented by every Iterator type). If you're delegating your iteration proper, the underlying iterator type will have likely have implemented those which are possible.

Since DerefMut inherit from Deref, you don't have to specify Target, pub trait DerefMut: Deref { use the Target define in Deref implementation.

Deref trait is very special, it can't really be use by "normal" user, almost only std can implement it for new type.

This is because it's borrow self and return a reference of "something else" problem is this something else can't be temporary, std use it control over rust ecosystem to be able to do that for example Vec implementation:

Path::new uses unsafe code to convert an &OsStr to a &Path: