A "Design FAQ" document

[bstrie]

In the vein of the Project FAQ and the Language FAQ.

In addition to being really interesting, this would save a lot of time and divert a lot of potential questions in the long run. Some topics to discuss:

• Why was typestate removed?
• Why are some types nominal instead of structural?
• Why do I have to declare impls in the same crate as a type or trait?
• Why is trait inheritance the only means of inheritance?
• Why doesn't Rust do tail-call optimization?
  (see e.g. rust-dev post.)

Explanations should be technical and include code examples wherever possible.

Some of the questions of this nature overlap with the latter half of the Language FAQ, but not all, e.g. "Can Rust code call C code?" and "What is the difference between a managed pointer and an owned pointer?" do not belong. The document should focus on large-scale design decisions and tradeoffs; think "Why split stacks?" rather than "How do split stacks work?".

If you think of good questions, add them in the comments here. There are probably a lot of ripe areas for explanation, especially with regard to mutability and regions.

[brson]

The manual has a related (and empty) section: http://dl.rust-lang.org/doc/0.4/rust.html#appendix-rationales-and-design-tradeoffs

[bstrie]

Why are &str, @str, ~str, &[], @[], and ~[] treated differently from &T, @T, and ~T?

[bstrie]

Why are early returns disallowed within closures?

[bstrie]

Why are separate do and for constructs required?

[bstrie]

Why do traits in Rust depart from the design in the original traits paper?

[bstrie]

Why must imports be qualified relative to the crate?

[graydon]

These are great, please keep them coming

[catamorphism]

"What does const mean (and why)?" should be in there too, though I know we're thinking about renaming it (at least).

[bstrie]

Why feature conditions rather than exceptions?

[jruderman]

Why so many pointer types? Why not rely on escape analysis instead?

Answered at:

http://www.reddit.com/r/programming/comments/17hqg4/a_little_bit_rusty_practical_approach_on_rust/c85r1nc

[bstrie]

Why is the .times() method no longer defined on signed integers? (discussion on the specifics of integer literal inference)

[bstrie]

Why do borrow checks on @mut pointers happen at runtime?

[acertain]

Why are there no exceptions?

[bstrie]

Why is name resolution such an intractably hard problem?

<@pcwalton> I know of no other static language with declarative imports
            that allows (a) reexports; (b) glob import; (c) mutual
            recursion everywhere; (d) nested modules; (e) two namespaces
<@pcwalton> java doesn't have reexports, Go doesn't have nested modules
            or reexports, C# doesn't have reexports I don't think, C++
            doesn't have reexports or mutual recursion everywhere, maybe
            D...
<@pcwalton> ML and Haskell don't have mutual recursion everywhere and
            don't have reexports
<@pcwalton> mutually recursive modules too
<@pcwalton> most languages do not have mutually recursive modules
< bstrie> pcwalton: so what you're saying is that rust has once again
          failed to be unoriginal :)
<@pcwalton> well, as you said, Python
<@pcwalton> but Rust is trying to achieve Python's module system's
            expressive power in a static system
  jld tries to remember how the various Scheme module systems work
<@pcwalton> turns out that's pretty hard :)
<@pcwalton> jld: no mutual recursion
<@pcwalton> btw, ES6 hit the exact same problems we did
<@pcwalton> and had to pare down their module system as a result
<@pcwalton> anyway none of this is an excuse, we should make it easier to
            use
<@pcwalton> but I'm just saying it's not that easy...

[brson]

Here's a summary about dynamically sized types https://mail.mozilla.org/pipermail/rust-dev/2013-April/003933.html