Rust 1.46

Post by saagarjha » Thu, Aug 27, 2020, 8:16 PM UTC

jedisct1 wrote: post #86

nemothekid wrote: post #35

Earlier quoted context omitted.

> the borrow checker, I do conceptually understand lifetimes, but actually using them is tricky. I've been using Rust for a little over year, almost daily at work, and for several projects. I have a pretty good intuition about how the borrow checker works and what needs to be done to appease it. That said, I don't think I'm any closer to understanding lifetimes. I know conceptually how they are supposed to work (I ne…

I've been writing Rust code since before the 1.0 days, and I still can't understand lifetimes in practice. When the compiler starts complaining about lifetimes issues, I tend to make everything clone()able (either using Rc, or Arc, or Arc+Mutex, or full clones). Because if you start introducing explicit lifetimes somewhere, these changes are going to cascade, and tons of annotations will need to be added to everythin…

Post by noctune » Thu, Aug 27, 2020, 8:26 PM UTC

ragnese wrote: post #63

estebank wrote: post #59

Earlier quoted context omitted.

> how many function types does Rust have again? Three?). Depending on what you meant, there are more than three: * There are 3 traits, used by closures depending on their needs: * Fn(Args) -> Output * FnMut(Args) -> Output * FnOnce(Args) -> Output * *Every* `fn` is its own type (`fn() {foo}`) * Function pointers (`fn()`), which is how you pass the above around in practice > Rust is very much procedural. I think this…

I realized after I wrote the comment that I was really referring to the closure traits when I said that. And I really should have said "kind" instead of "type" because, like you said, every different function has its own type . But anyway, I don't really disagree with your point about categorizing languages as OOP, Procedural, or Functional. But honestly, in this case, I think it's pretty damn clear than Rust is proc…

    struct Foo(u8, u8);
    
    fn main() {
        let mut bar = Foo(1, 2);
        let Foo(ref mut x, ref mut y) = &mut bar;
        *x += 1;
        *y -= 1;
        println!("{} {}", bar.x, bar.y);
    }

Post by steveklabnik » Thu, Aug 27, 2020, 8:32 PM UTC

djhworld wrote: post #94

Is there a resource that explains what const functions are and why you would use them?

Post by Shorel » Thu, Aug 27, 2020, 8:42 PM UTC

sfvisser wrote: post #6

I’m learning rust right now and there is a lot to like. Steady updates like this are also very motivating. The ecosystem feels very sane - especially compared to npm. Top notch Wasm support, cross compiling is a breeze. That said, coming from a FP background (mostly Haskell/JS, now TS) Rust is... hard. I do understand the basic rules of the borrow checker, I do conceptually understand lifetimes, but actually using th…

Post by brundolf » Thu, Aug 27, 2020, 8:45 PM UTC

steveklabnik wrote: post #10

cordite wrote: post #4

These const fn’s are cool, but won’t this also lead to long compile times down the road?

Yes, any time you move computation to compile time, it makes the compile time take longer. As always it is a tradeoff. One thing that people may not realize, especially now that we have loop. You may expect this to hang the compiler: const fn forever() -> ! { loop { } } static FOO: u32 = forever(); But it won't: error[E0080]: could not evaluate static initializer --> src/lib.rs:2:5 | 2 | / loop { 3 | | 4 | | } | | ^…