+972 52-548-6969
Uninformed comments on Rust
So my current project is to learn Rust. This is part of firm belief that if you don’t actively extend your reach, you’ll be forever stuck in an infinite loop. So Rust it is.
Why Rust? Because the previous time I did something like that I looked at Go, which is nice, but except for green threads (which I’m familiar with from Erlang), it is pretty much the same old thing. I’ll admit that the compilation speeds are pretty attractive there, but I’m working mostly on system software this days, and it seems like it is almost there, but not quite.
So the choice was between Rust and modern C++. The last time I actually did any C++ professionally was in 2006, I needed to build a tool to make a machine join the domain automatically, or something like that. I remember being stuck for an embarrassing long time on “using std” vs “using namespace std”. Before that, I actually did C++ for a few years, in 1999- 2002 or so. I was below average, at best, but I had read all the Myers books, and I had great confidence that I can mess up real well.
But C++ today is a wildly different beast, much nicer, but at the same time… The core concepts (memory management, RAII, etc) I already know, and a lot of the rest seems like stuff that I now take for granted (foreach, auto,lambdas, not doing manual memory management all the time, etc). Looking into modern C++ codebase and discussion, I see a lot of stuff about move constructors and variadic templates. That caused me some pain, but basically, there isn’t anything new there for me, just detail work.
Rust is new, in the sense that it has the Burrow checker and it is supposed to be a safe & fast system programming language. That seems like a big contradiction in term, but it is at least interesting.
So I set out to read the Rust book. I have done so, and below you can see some of my impressions while reading it.
This post is written before I did anything more interesting than writing a hello world.
Rust has macros, and I like that. Should be interesting to see what it can do. Okay, I saw what it can do, and I sort of want to go back to variadic templates. To be rather more exact, that syntax looks sort of the same. And remind me strongly of trying to grok XSLT in the 90s.
I like that it has explicit threading support, and it is interesting that this is baked directly into the language and checked by the compiler. Although some of the stuff that is mentioned there is fishy (Rc<RefCell<Vec<T>>> and other strangeness), but then again, I’ve literally just read the book, so need to see how this work out in practice.
Something that was really strange during the reading is that Rust uses the type of the assignment to infer types.
Speaking of this, I’m used to languages that have far less syntax. In comparison, it seems like Rust have a lot of stuff going on. Most of it seems to be optional / inferred, but that is surprising.
Loop labels and named break / continue are really nice. They are always ugly when you need them.
And obviously the type system is quite sophisticated. I’m going to see how hard it is going to hurt me when I try writing actually stuff with it.
Comments
I've never used Rust, but I think it's actually "the borrow checker".
Svick, I know, but I like my version better :-)
Note that you can't actually do multithreading with that one:
Vec<T>is a plain vector (a generic arraylist), nothing special. It's not a copyable type so if you give aVec<T>to an other function you lose it (it's moved, that's the default state of types in rust, the other one is Copy types where the instance is memcpy'd).Rcis a reference-counted smart pointer, but not a thread-safe one (that'sArcwhich uses atomic reference-counting), that's useful if the ownership of an object (here a Vec) is unclear, and you want multiple bits of code to have access to the Vec itself. Aside from not being atomic it's basically C++'s shared_ptr.RefCellinbetween is the interesting part. See, by defaultRc<T>dereferences to to&T, so you can't modify the value in anRcorArcas that would not be safe.RefCellimplements "interior mutability" (it creates a mutable context within an immutable one) and allows mutably borrowing those values by tracking the borrows dynamically at runtime. IncidentallyRefCellis also a single-thread tool, the multi-threaded version isRwLockorMutex.What else would it use?
Masklinn, C type langs typically don't use information from the left side of the
=for inference.@ayende: true for the general case, I guess it wasn't clear that I was wondering what else Rust would use for
str::parse: without "destination-based" inference you I don't think you can have a function which is generic only in its return value, so str.parse() (or Default, or From) is outright impossible is it not?Mashklinn, Indeed, for the most part, those langs don't have overloading or generic params on the return value with inference.
Go is much simpler than other languages and this is the selling point along with the green ones. Rust is another complex beast for my taste. But it is fast and has the borrowing that is a interesting concept. I had to choose between them and did go with go plus the community of go is amazing. Huge projects are build with go... my next step would be a functional language (i have started some time ago with F#)... but i would like to go outside the ms ecosystem for obvious reasons.
If you've ever use a language that's derived from ML, like Haskell or Ocaml, the type inference would be rather tame (Rust's inference algorithm is a variant of H-M that is guaranteed to avoid going O(n^2)).
Exponential, not quadratic. Teach me to pontificate about things I've read about, but never used.
http://spacemanaki.com/blog/2014/08/04/Just-LOOK-at-the-humongous-type/
Comment preview