Rust 1.49.0

Post by steveklabnik » Thu, Dec 31, 2020, 4:11 PM UTC

rapsey wrote: post #40

boxmonster wrote: post #19

I recently wrote a utility for myself in Rust after having done several in C#. I like both languages, but Rust introduces pain points for no apparent reason. For example, I hate this way of dealing with errors match result { Ok(value) => value, Err(result) => { panic!("error traversing directories {}", result); } }; It's awkward and ugly. I'm back to C#, now on .NET 5.) and find that it just got noticeably faster! It…

This is pretty nonsensical code so kind of hard to see what your point is.

Post by lumost » Thu, Dec 31, 2020, 4:13 PM UTC

steveklabnik wrote: post #35

lumost wrote: post #22

Earlier quoted context omitted.

It might be worth separating the different improvement areas by section to let people zoom in on what they care about.

We already do that in a pretty granular way, between language, library, compiler, and toolchain features, unless I'm misunderstanding you. Regardless, I don't think the cost/benefit is right here; the posts and notes are already pretty short, and should only take a few minutes to read, even if you read all of them.

Post by brundolf » Thu, Dec 31, 2020, 4:15 PM UTC

option_greek wrote: post #36

steveklabnik wrote: post #27

Earlier quoted context omitted.

Rust has From/Into and TryFrom/TryInto that do the same thing, as far as I can tell. It's not clear to me what the differences are, maybe someone else in this thread will know. :) > Why not hide it a bit by letting the implicit copy to happen to simpler structures ? This is the Copy trait. > Why no love for inheritance There are a variety of reasons, but one interesting one is that inheritance and strong type inferen…

Sorry for got to mention the 'mutable' part. So a mutable singleton variable that has to be marked with an unsafe keyword (and forces the functions that use to be marked as unsafe). The other day I was struggling to implement a singleton (for loading large data from disk) and finally decided to just pass it down the whole chain from the main method. May be I'm missing some easy pz way of doing this ?

  #[macro_use]
  extern crate lazy_static;

  use std::sync::Mutex;

  lazy_static! {
    static ref ARRAY: Mutex> = Mutex::new(vec![]);
  }

  fn do_a_call() {
    ARRAY.lock().unwrap().push(1);
  }

  fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", ARRAY.lock().unwrap().len());
  }

Post by steveklabnik » Thu, Dec 31, 2020, 4:18 PM UTC

brundolf wrote: post #46

option_greek wrote: post #36

Earlier quoted context omitted.

Sorry for got to mention the 'mutable' part. So a mutable singleton variable that has to be marked with an unsafe keyword (and forces the functions that use to be marked as unsafe). The other day I was struggling to implement a singleton (for loading large data from disk) and finally decided to just pass it down the whole chain from the main method. May be I'm missing some easy pz way of doing this ?

Here's how you can do global mutable state in Rust: #[macro_use] extern crate lazy_static; use std::sync::Mutex; lazy_static! { static ref ARRAY: Mutex > = Mutex::new(vec![]); } fn do_a_call() { ARRAY.lock().unwrap().push(1); } fn main() { do_a_call(); do_a_call(); do_a_call(); println!("called {}", ARRAY.lock().unwrap().len()); } I agree that this isn't the most ergonomic, but like most unergonomic things in Rust, t…

Post by johnsoft » Thu, Dec 31, 2020, 4:23 PM UTC

the_duke wrote: post #34

option_greek wrote: post #20

Earlier quoted context omitted.

In C# there is a helper class: https://docs.microsoft.com/en-us/dotnet/api/system.convert?v... I'm still figuring my way around rust so obviously some noob questions follow: -> what's with the move/copy mess ? I know why they are needed but it seem to be in the face with all the explicit '&' all over the place in any reasonably sized code. Why not hide it a bit by letting the implicit copy to happen to simpler struct…

You are essentially complaining that Rust is not C#, while at the same time admitting that you don't know much about the language. Rust is much lower level and makes very different tradeoffs. Sometimes for the sake of performance, sometimes to enhance code readability. But most of the design decisions are there for a reason, and are good choices. Simple types (that are small and can be trivially memcopied) can implem…