Jag har förstått att det kan vara svårt att ha en familjemedlem som tolk om samtalsämnet är något man inte vill att de ska ta del av. En neutral tolk (kanske med tystnadsplikt) kan vara mer privat och minska risken för att man undviker att prata om något som kan vara viktigt att ta upp.

Med det sagt tycker jag att förbud låter drastiskt.

Mycket enkelt om rätt personer blir drabbade.

Same, but I’m feeling better today

A relatively cheap PC with Factorio and you are set. You won’t spend much on food either, so win-win.

Reject C, return to assembly. Structured programming is the true oppression our generation never talks about.

That’s silly. Luckily, I don’t think this was the same situation. This was at a university and they had classes with other languages. The beginner classes were split into two variants, where some students (mostly CS students) learned C, and other students (economy, etc.) learned Python. I suppose they figured it was more useful to them or something.

I was a teacher’s assistant in beginner’s programming at university for a bit. I expected them to learn C, which I knew enough of, but I got assigned to a group that learned Python instead. I had never used Python at the time. I ended up having to speed learn it while trying to teach it, to not be completely useless.

https://youtube.com/shorts/c6kNX2HusaM

A closure may/will try to capture by reference, so it may hold references to the calling function’s scope. For example, this would want to hold a reference to x:

let x = 0;
std::thread::spawn(|| x += 1);

It’s as if you had a struct like this:

struct MyClosure<'a> {
    x: &'a mut i32,
}

That makes the closure non-'static, since it holds non-'static references. The usual solution is to use the move keyword, to hint that you want it to move by default, or to use scoped threads. But yeah Send and 'static depend on the captures.

Am I correct in guessing that you handle is of Gontian origin?

Yes! 😁 I picked it when I used to play Tibia (15-20 years ago!), and it stuck with me since then. The correct spelling was already taken, so I modified it a bit. This name is usually available.

Your guess is correct, it should be understood as

F: ( FnOnce() -> T ) + Send + 'static
T: Send + 'static

The FnOnce() -> T is syntax sugar for FnOnce<(), Output = T> and the bounds after apply to F. That’s also why T has separate bounds. They aren’t propagated or inherited. It’s just an ambiguous looking syntax, but T + Trait + 'lifetime isn’t a valid syntax for applying bounds to T (unless I missed something).

The type F may be a closure over values from the calling thread. It has to be possible to send these values to the spawned thread, hence F needs Send + 'static. When the thread is done with its work, it returns a value of type T that gets passed back via JoinHandle<T>, so T needs Send + 'static too.

I hope this cleared things up a bit.

Det är ändå redan för sent. Det är buskens hus nu.

That’s definitely part of “the deal” with MIT and Apache. The other end of it is that they shouldn’t really expect to get anything more than what the authors are willing to give.

Right, there may be too many unknowns involved. 🤔

deleted by creator

Option<T> has a From<T> implementation that lets you write Option::from($file_path).map(|path| path.to_string()) to accept both cases in the same expression.

https://doc.rust-lang.org/std/option/enum.Option.html#impl-From<T>-for-Option<T>

Zooming in? In this economy?!

“Search prompt engineer”

Yeah, they look a bit stale.

How much is that in ™?

The rabbit hole goes deep if you really feel like going spelunking. A basic understanding of RGB, HSV and HSL takes you very far and lets you do a lot of things already. It’s good enough as long as it looks good, after all. 🙂

You really don’t need to read all of it to get started!