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

My favorite Rust function

blog.jabid.in

Post reply on HN
Print view View original

61–70 of 197 posts

Re: My favorite Rust function

#61

Post by The_rationalist »

nicoburns wrote: post #50
gautamcgoel wrote: post #17

Gotta admit, that really is a cute example. However, I was a bit surprised when the author described Go as "unacceptably crippled." What is he referring to?

Go code feels very low-level to me, and very boilerplatey. In Rust I can write code that in almost the same way I write JavaScript (but with added type annotations), but Go makes me deal with all the little details, and makes it hard to abstract things neatly. Lack of generics is a big part of the issue. But more generally the focus on "simple" code means that more sophisticated abstractions are actively eschewed, an…

Your comment is weird. The one making you deal with the little details should be rust, e.g go is garbage collected. Secondly, javascript + type annotations is typescript.

Re: My favorite Rust function

#62

Post by fao_ »

cztomsik wrote: post #39

For me, rust is still love & hate, even after 1 year of half-time (most of the free time I have) hacking. It's a wonderful language but there are still some PITAs. For example you can't initialize some const x: SomeStruct with a function call. Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages…

> Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages.

While someone else is right that "zero-cost" refers to runtime cost rather than compilation cost, dependencies are the biggest problem.

The program `spotifyd` takes over an hour to compile on my X200 laptop. This is, for reference, the same amount of time that the Linux Kernel and GCC takes to compile (Actually, I think GCC takes less time...). Most of the compilation time is on the 300+ dependencies, that simply wrap C (and in some places, replicate) libraries that I already have installed on my system!

Re: My favorite Rust function

#63

Post by coldtea »

cztomsik wrote: post #39

For me, rust is still love & hate, even after 1 year of half-time (most of the free time I have) hacking. It's a wonderful language but there are still some PITAs. For example you can't initialize some const x: SomeStruct with a function call. Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages…

>Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages.

"(...) there are two factors that make something a proper zero cost abstraction:

No global costs: A zero cost abstraction ought not to negatively impact the performance of programs that don’t use it. For example, it can’t require every program carry a heavy language runtime to benefit the only programs that use the feature.

Optimal performance: A zero cost abstractoin ought to compile to the best implementation of the solution that someone would have written with the lower level primitives. It can’t introduce additional costs that could be avoided without the abstraction."

https://boats.gitlab.io/blog/post/zero-cost-abstractions/

It's not about compile time...

Re: My favorite Rust function

#64

Post by Rusky »

The_rationalist wrote: post #57
cztomsik wrote: post #39

For me, rust is still love & hate, even after 1 year of half-time (most of the free time I have) hacking. It's a wonderful language but there are still some PITAs. For example you can't initialize some const x: SomeStruct with a function call. Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages…

Another PITA is the lack of safe static variables.

Rust does have safe static variables. You just need a) to use interior mutability (`static mut` is a very strange feature that should probably never have existed) and b) to ensure that its type is `Sync` (since multiple threads can obtain references to it).

For example, use an atomic integer: https://play.rust-lang.org/?version=stable&mode=debug&editio...

You can also use types built on std::sync::Once and UnsafeCell, like once_cell::Lazy>. This will get even easier as we get `const fn` constructors for locks in the future.

Re: My favorite Rust function

#65

Post by kam »

The_rationalist wrote: post #57
cztomsik wrote: post #39

For me, rust is still love & hate, even after 1 year of half-time (most of the free time I have) hacking. It's a wonderful language but there are still some PITAs. For example you can't initialize some const x: SomeStruct with a function call. Also, zero-cost abstraction is likely the biggest bullshit I've ever heard, there is a lot of cost and there's also a lot of waiting for compiler if you're using cargo packages…

Another PITA is the lack of safe static variables.

Try https://docs.rs/once_cell/

Re: My favorite Rust function

#66

Post by Gaelan »

The_rationalist wrote: post #61
nicoburns wrote: post #50

Earlier quoted context omitted.

Go code feels very low-level to me, and very boilerplatey. In Rust I can write code that in almost the same way I write JavaScript (but with added type annotations), but Go makes me deal with all the little details, and makes it hard to abstract things neatly. Lack of generics is a big part of the issue. But more generally the focus on "simple" code means that more sophisticated abstractions are actively eschewed, an…

Your comment is weird. The one making you deal with the little details should be rust, e.g go is garbage collected. Secondly, javascript + type annotations is typescript.

Disclaimer: I’ve never tried to write Go.

Memory management is not the only type of “little detail.” For instance, rust provides common collection operations (filer, map, find…) in the standard library. In go (AFIAK), you need to hand-write a loop for each. IMO, the rust version is takes much less mental bandwidth to write and understand.

Re: My favorite Rust function

#67

Post by Rusky »

edflsafoiewq wrote: post #53
klipt wrote: post #13

Earlier quoted context omitted.

void drop(unique_ptr && x) {} Would do the same in C++ for values held by unique_ptr: take ownership of the pointer and then free it.

The equivalent to drop in C++ would be template void drop(T&) = delete; // force callers to move template void drop(T&& x) { T drop_me(std::move(x)); } edit: fixed.

This is not correct; moves must leave the value in a valid state, because its destructor will still run. The correct version is actually the same as Rust's:

    template 
    void drop(T) {}
(Moving into a local in `drop(T&&)` also works.)

Re: My favorite Rust function

#68

Post by [deleted] »

dkersten wrote: post #56
Rusky wrote: post #44

Earlier quoted context omitted.

Yes, you're missing that the type `T&&` is a reference, not a value, and so does not run the object's destructor when it goes out of scope.

Sorry, I edited right after hitting reply to clarify that I'm assuming the intention was to std::move the unique_ptr in, since it was T&& and not T&. Would that still not work?

[deleted]

Re: My favorite Rust function

#69

Post by edflsafoiewq »

Rusky wrote: post #67
edflsafoiewq wrote: post #53

Earlier quoted context omitted.

The equivalent to drop in C++ would be template void drop(T&) = delete; // force callers to move template void drop(T&& x) { T drop_me(std::move(x)); } edit: fixed.

This is not correct; moves must leave the value in a valid state, because its destructor will still run. The correct version is actually the same as Rust's: template void drop(T) {} (Moving into a local in `drop(T&&)` also works.)

You're correct, sorry (I did have that at one point...). But the equivalent of Rust's pass-by-moving is to pass an r-value reference. Passing a const reference to drop is certainly an error and should be disallowed.

Re: My favorite Rust function

#70

Post by [deleted] »

The_rationalist wrote: post #61
nicoburns wrote: post #50

Earlier quoted context omitted.

Go code feels very low-level to me, and very boilerplatey. In Rust I can write code that in almost the same way I write JavaScript (but with added type annotations), but Go makes me deal with all the little details, and makes it hard to abstract things neatly. Lack of generics is a big part of the issue. But more generally the focus on "simple" code means that more sophisticated abstractions are actively eschewed, an…

Your comment is weird. The one making you deal with the little details should be rust, e.g go is garbage collected. Secondly, javascript + type annotations is typescript.

[deleted]
Post reply on HN