Closures | Swifty closures for UIKit and Foundation | iOS library

Your problem is that you have set SESSION_CONNECTION=session, but your SESSION_DRIVER=default, so you have to use SESSION_DRIVER=database in your .env. See the config/session.php:

In order to understand what's going on, I'll reformat the code a bit in order to make it more clear and explicit:

Your original code:

The compiler seems to be complaining that it's expecting a type parameter but finds a closure instead. It knows the type, and doesn't need a type parameter, but also the size of the closure object isn't fixed, so you can either use impl or a Box. The closure will also need to use move in order to move the data stored in x into the closure itself, or else it wont be accessible after equal_5() returns, and you'll get a compiler error that x doesn't live long enough.

Pass completion handler of main function and status code to fetchAllUsers and call it there after it's own completion handler

completionHandler(response.response!.statusCode) was being executed before self.fetchAllUsers closure because it was waiting for api response to complete. completionHandler(response.response!.statusCode) was destroying self.fetchAllUsers closure before it is executed, so I called completionHandler(response.response!.statusCode) inside self.fetchAllUsers after it's closure

There is a problem in your minusChancesRecursivly where you are accessing chances in the settimeout. The value of chances will stay the same all every time you call the function as the value when you called it. You can fix this by putting the code in the callback you are passing to the setChances where it receives the current value of the chances in your prev argument.

But better approach to this will be passing the current chances value to the function as argument like so

The compiler needs to be able to deduce the type of the argument in some way, this can happen through explicit type annotations as in num: i32 or through contextual information such as

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:

But now the rust compiler complains about the lack of a lifetime parameter for the returned reference in the type specifier of cell_access:

The problem here, as I understand it, is that in order to be able to write the code in this shape, the cell_access function's signature needs to refer to the lifetime for which it is valid, and this is impossible because that lifetime doesn't have a name — it's a local reborrow of self that's implicit in the closure creation. Your attempt with &'a mut self doesn't work because it doesn't capture the fact that the closure's self is a reborrow of the function's self and accordingly does not need to live exactly the same lifetime, since mutable borrows' lifetimes are invariant rather than covariant; they can't be arbitrarily taken as shorter (because that would break the exclusiveness of mutable references).

That last point gives me an idea for how to fix this: move the all_in_line code into a function which takes self by immutable reference. This compiles:

The following code works fine: