Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Rust 1.49.0

blog.rust-lang.org

Post reply on HN
Print view View original

31–40 of 117 posts

Re: Rust 1.49.0

#31

Post by steveklabnik »

ChrisSD wrote: post #23
steveklabnik wrote: post #18

Earlier quoted context omitted.

Strings implement a lot of different conversions, since they're very general. You've got: * Into, with s.into() * An inherent method, .as_str() * Deref coercion, &s * Reborrowing, &*s (this builds on Deref too but isn't a coercion and can be done in places where coercion doesn't kick in) ... and probably some others I'm forgetting.

Right but as a general rule you'll mostly only be using `s.into()` to get a `String` from an `&str`. Or `&s` to deref `String` to a `&str`. I'm not sure why this would require a crate to handle? The other ways are more "advanced", for when you're dealing with (for example) potentially unsafe coercions or you don't want to rely on inference for some reason.

I agree with you that I'm not sure what your parent is talking about, I'm just here to give all the examples. Deref coercion takes 99% of my String -> &str conversions, and I reborrow for that rare 1%, personally.

Re: Rust 1.49.0

#32

Post by dbrgn »

deccanchargers wrote: post #26

Nice. Rust is nice language btw. But,when will stable version of Rust be released? By stable,i mean, number of new features added must not be too much. Rust currently seem to be adding too many features every release (which is nice but also not so good at same time)

By that measure, both Java and JavaScript are highly unstable programming languages.

Re: Rust 1.49.0

#33

Post by steveklabnik »

deccanchargers wrote: post #26

Nice. Rust is nice language btw. But,when will stable version of Rust be released? By stable,i mean, number of new features added must not be too much. Rust currently seem to be adding too many features every release (which is nice but also not so good at same time)

> By stable,i mean, number of new features added must not be too much

What is "too much"? How many would you prefer? How does this release have too many features? This release has three, and they're all pretty small. Some could even argue that they may not even count as new features, but remove restrictions between combinations of existing features.

Re: Rust 1.49.0

#34

Post by the_duke »

option_greek wrote: post #20
steveklabnik wrote: post #15

Earlier quoted context omitted.

> the conversions between String and &str are really ugly to look at. This is entirely up to you; unless you find method calls ugly, in which case, you've got bigger problems :) > They need to take more inspiration from C# Could you elaborate a bit? I'm not familiar with what C# does here.

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 implement the `Copy` trait, which makes cloning transparent. For other types, the `Clone` trait is there with `.clone()`. Having expensive copies be explicit is a intentional design decision.

For value conversions, the `Into/From` and `TryInto/TryFrom` traits make conversions a (usually type inferred) function call (.into(), .try_into()), which is really quite convenient, though at the expense of readability.

Regarding strings: they are are definitely complicated and sometimes awkward in Rust. But I'd argue that strings are inherently complicated. Most languages hide this complexity by just allocating and doing everything on the heap, which is not great in a language that values performance and wants to support environments without allocators.

Re: Rust 1.49.0

#35

Post by steveklabnik »

lumost wrote: post #22
steveklabnik wrote: post #16

Earlier quoted context omitted.

Yeah, it's just impossible to please everyone, especially in releases like these, which have a few minor things and that's it. Rust 1.51 will be easy, given that "const generics" is a huge headline feature almost every Rust user will care about, but for features that are full of tiny things, it's just way way less clear. This has the funny effect of posts getting harder to write as time goes on; we have less releases…

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.

Re: Rust 1.49.0

#36

Post by option_greek »

steveklabnik wrote: post #27
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…

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 ?

Re: Rust 1.49.0

#37

Post by alpaca128 »

steveklabnik wrote: post #15
option_greek wrote: post #12

I wish they would streamline the string handling capabilities. Currently the conversions between String and &str are really ugly to look at. In general the conversion between types don't seem all that great with developers having to either use crates or write their own code. They need to take more inspiration from C# which continues to be the benchmark of elegance (obviously personal opinion). That said, rust is stil…

> the conversions between String and &str are really ugly to look at. This is entirely up to you; unless you find method calls ugly, in which case, you've got bigger problems :) > They need to take more inspiration from C# Could you elaborate a bit? I'm not familiar with what C# does here.

What I tend to stumble over is how String and &str each have some methods and features that the other lacks, e.g. concatenation. Which of course makes sense with basic understanding of string slices, but sometimes I can't shake the weird feeling that I'm cloning some String unnecessarily.

And I just wish generic type parameters wouldn't have to be propagated through all types touching them.

That said I'm really happy with how it develops and Rust comes with many little details that I sorely miss in other languages. Thanks for all the effort.

Re: Rust 1.49.0

#38

Post by brundolf »

option_greek wrote: post #20
steveklabnik wrote: post #15

Earlier quoted context omitted.

> the conversions between String and &str are really ugly to look at. This is entirely up to you; unless you find method calls ugly, in which case, you've got bigger problems :) > They need to take more inspiration from C# Could you elaborate a bit? I'm not familiar with what C# does here.

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…

If you just prefer the "helper" style of calling, Rust allows methods to be called either way:

  let foo1: String = "bar".into();
  let foo2 = core::convert::Into::into::("bar");

Re: Rust 1.49.0

#39

Post by shepmaster »

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 ?

https://stackoverflow.com/q/27791532/155423

Re: Rust 1.49.0

#40

Post by rapsey »

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 reply on HN