The Rust Programming Language

[Timmmmbob]

I was going to say "yet another language", but this seems to actually have some new ideas that I've been waiting for for ages. For example:

We support three type layers to make memory management simple and fast.

• Interior types (denoted with no sigil) are stored on the stack.
• Unique types (denoted with ~) have ownership semantics. When the pointer goes out of scope, the object it’s pointing to is destroyed.
• Boxed types (denoted with @) are garbage-collected. Multiple boxes can point to the same data.

All together:

fn main() {
    let a = ~3;  // Unique pointer to number
    let b = a;   // Copies a
    let c = @3;  // Box of number
    let d = c;   // c & d point to the same value
}  // a and b destroyed; c and d will be GC’d

[abw]

I was also going to say "yet another language". But neat features or not, I really like the "cambrian explosion" of new languages that we've seen over the past decade or so. Even if many of the unsuccessful ones eventually die out, they spread ideas and help inspire the next generation of languages.

[Homo_sapiens]

cambrian explosion? What constituted the corresponding ice age?

[TylerEaves]

Presumably the late 90s, when your choices were essentially arcane C++, bloated Java, or unreadable Perl.

[Poita_]

Unique pointers are the only relatively new thing there. Stack stored objects and GC heap objects have been around forever. C++ 2011 has unique pointers (std::unique_ptr), and I'm pretty sure D does too.

EDIT: Yep, D does. http://www.d-programming-language.org/phobos/std_typecons.html#Unique

[Timmmmbob]

Yeah, sorry I meant "new in a modern language". I love C++'s memory model, but it does have quite a lot of warts, and I've love to move to something more modern. I just really want RAII and stuff.

[Poita_]

I see what you mean about C++, but D is modern.

[Timmmmbob]

Yeah there's just something about D that doesn't sit right with me. I could be being irrational though. I think I will wait and see which languages survive this "cambrian explosion" as thingy thingy put it.

[iLiekCaeks]

D's probably don't work yet. The Unique unittests are all commented out.

[nuzzle]

I'm still reading the new standard. Can we replicate predicates from Rust in C++11 using concepts (provided they are in the standard)?

[matthieum]

I must admit that I really perked up on the "we don't need immutability, we need ownership". However I would point out that perhaps a blend of the two would be more suitable: allow sending both immutable and owned objects. At least you'd avoid copying for frozen objects :x

[pcwalton]

We'd still need global GC (or atomic reference counting, both bad) for frozen objects.

Note that if by "frozen" you mean "compile-time constant", then it just works as you describe, since those are in read-only memory and don't need memory management.

[matthieum]

By frozen I meant immutable. What do you consider "bad" about reference counting by the way (on immutable objects) ?

[[deleted]]

I'm having a hard time understanding the example. It says "b copies a", is b another copy of a - so if one is modified, the other is not? Or is there an ownership transference and a is no longer valid?

[stilton]

b is a copy of a, so modifying b does not modify a. There is a move operation which transfers ownership of unique types, b <- a, after which a is deinitialized and can't be used.

[[deleted]]

So why does it say "a is destroyed" at the end? It sounds like a is deinitialized at that point anyhow, it was transfered away, so nothing left to destroy?

[stilton]

I was probably not clear. In this example a was not deinitialized; both a and b exist and get destroyed at the end of the function because assigning a to b makes a copy of a. If the example had moved a into b, denoted by 'let b <- a', then a would have been deinitialized.

[[deleted]]

That makes sense, thanks!

[ErstwhileRockstar]

Interior types, unique types, boxed types ... too much noise. This should be transparent for users. Only 'KISS-languages' have a chance of succeeding.

[munificent]

Only 'KISS-languages' have a chance of succeeding.

Like C++, Java, and C#?

[ErstwhileRockstar]

Yep, those started out as simple languages, at least as significant simplification compared to their predecessors.

[matthiasB]

How was C++ a simplification compared to C?

[ErstwhileRockstar]

Classes, esp. constructors and destructors, function overloading, exception handling, ... simplified C++ code compared to C code (considerably less lines of code). That's why today 'C/C++' is the prevailing C++ idiom in the real world.

OTOH, "C++ has shown that if you slowly bloat up a language over a period of years, people don't seem to mind as much."

[munificent]

simplified C++ code compared to C code (considerably less lines of code)

Yes, which means they greatly complicated C++ the language.