RustyYato

@Lucretiel Yep, this does look like a shortcoming in the trait solver. Esp. because this works play.rust-lang.org/?version=stabl… pub trait Foo<T> {} impl<T> Foo<T> for T {} impl<T> Foo<(T, T)> for T {}

I believe I found a bug or shortcoming in the trait resolver. Currently, the compiler believes that these are conflicting implementations: impl<T: Trait> Extend<T::Item> for MyStruct<T> { ... } impl<T: Trait> Extend<(T::Item, T::Item)> for MyStruct<T> { ... }

@LizardOrman @ejpbruel @jameskjx @timClicks Every data race is a race condition. But not all race conditions are data races

@LizardOrman @ejpbruel @jameskjx @timClicks For example you could have a mutex<i32> which is set to 1 on thread A and set to 2 on thread B. The final value depends on which thread runs last, but there's no way of knowing which one. This is a race condition. But there isn't a data race, because of the mutex.

One of the nice things about Rust is that you never have to ask "Is this code threadsafe?". Consider this innocent-looking Java code, which is definitely not. public class Counter { private int count = 0; public void increment() { count++; } }

@LizardOrman @ejpbruel @jameskjx @timClicks Race condition != data race Rust prevents data races, not race conditions. Race conditions are a much more general issue

@ejpbruel @jameskjx @timClicks It should not be possible to create race conditions within safe Rust that doesn't interact with external systems AFAIK

@timClicks Idris, Agda, Coq, etc. Basically a dependently typed language. Haskell also seems to be moving to this direction but isn't there yet

What, pray tell, is a "sophisticated programming" language?

Hardware people: "in a high-level language like C" Functional Programmers: "in a low-level language like C" Functional Programmers: "in a high-level language like Haskell" PL theorists:

@Lucretiel This isn't possible in by example macros because you can't split tokens or semantically analyze them in any way. You could go the other way and stringify a type name though

My question is: I have a macro taking a literal, and I want the macro to produce a trait implementation that includes that literal’s type as a generic parameter: tag(“str”) -> impl MyTrait<&str> { … }

ChatGPT is now 3 for 3 with answering my programming questions with a wrong answer. At least this time I was able to provoke it into telling me that what I’m trying to do isn’t possible, something I was only 70% sure was the case

Rust's Creator Graydon Hoare Recommends Lean 4 for Those Seeking Advanced Types—Honored by the Mention. 🙏 #LeanProver #RustLang @graydon/111033807456349023" target="_blank" rel="nofollow noopener">types.pl/@graydon/11103…

Don't let #WEB3 hold you back - with #RustLang, you can build applications people love, from traditional web backends to databases, command line tools, machine learning, games and more! Join the Rust 🦀 community and build a better world with us!

Chrome is hot garbage. A long time ago it was a snappy rebel browser that took the Internet by storm. Today it's worse than IE ever was, tracking your browsing habits and sharing them with advertisers even if you take efforts to protect your privacy. It's all out-out too.

@Lucretiel Not if you don't drop any generic values :). Rust is smart enough to figure this out in trivial cases but falls over pretty quickly.

@RustyYato That would preclude all generic const fn, but you can definitely have generic const fn

TFW `unwrap` is const but `unwrap_or` isn't

The other fucked up part? Imagine putting blood sweat and tears into your event and it's just casually dismissed as a "tier 2". You know, the place where things that aren't ready like my "not supposed to be a keynote" goes. Holy moly donut shoppe!

Someone sending me the statement (gist.github.com/dtolnay/7f5da4…) and me getting to the part about my "skepticisms".

"Here's a read-only mirror of a write-up [...]. Comments are locked because the previous discussion was largely unconstructive" in itself really sounds very unconstructive. Please for the love of god can we as a Rust community have an adult conversation over what happened?

I knew I fucking hated this guy

@maybewaffle Ah, didn't see your post till now. Very nice!

@maybewaffle That wasn't too bad. Using deref to get a callable on stable was the key insight play.rust-lang.org/?version=stabl…

@jorendorff @nick_r_cameron This is the way

@nick_r_cameron Or, you can monkeypatch `&mut [T]` to have the methods you want: play.rust-lang.org/?version=stabl…

I have a field `f: &mut [T]` and `&mut self`, I want to do `self.f = &mut self.f[1..]`; but I can't because lifetimes. Is there something else I can do which will work?