3 ms·

> The compiler is complex and slow. It doesn't mean that the language is complex. > The borrower semantics is anything but simple. The borrow checker doesn't

> The compiler is complex and slow. It doesn't mean that the language is complex. > The borrower semantics is anything but simple. The borrow checker doesn't change the meaning of the program in any way. You can perfectly understand Rust code without any knowledge of the borrow checker (there is a working Rust compiler that doesn't even have a borrow checker), so it cannot make the semantics of the language more complicated. > It isn't uncommon for the syntax to look arcane. Again, I did call out the syntax has being moderately complicated. The great thing about syntax is that it's superficial. Syntax has to be pretty bad to continue being an issue beyond the initial stages of learning a language, and I don't think Rust's syntax is close to being that bad, it just has some unfamiliar elements to a lot of people. > The standard library is shallow often making developers have to resort to third party libraries for trivial things. This sits on the "Rust is simple" side. > Rust improved upon languages like Cyclone but it's a far cry from being the next C/C++ when it comes to potential market adoption. In terms of actual market adoption I'd agree. But you said potential market adoption, so I don't.

wbl 7y ago
You don't think the type system is part of language semantics?
- Tuna-Fish 7y ago
  The borrow/lifetime system never changes the behavior of any program, the only thing it can do is to disallow some programs from compiling. This is not how the rest of the type system works. This means that it's possible to write a compiler that correctly compiles all correct rust programs without having a lifetime system at all. It also means that having the lifetime system in makes writing programs more complicated, but it makes reading them, and understanding what a program does, easier.
  - wbl 7y ago
    Ownership is linear types. It's part of the type system.
    - Tuna-Fish 7y ago
      Yes, but borrowing isn't, and ownership is by itself no more complicated than RAII.
- Diggsey 7y ago
  The type system is yes, just not the borrow checker or the type checker. The type system is still relatively simple compared the type systems in Java/C#/C++/etc. Let's take Java's as an example because I think people regard it as being simple: Building blocks of the type system: Rust: Types, Traits Java: Primitive types, classes, interfaces, (value types yet?) Relationships between those building blocks: Rust: Implements (Type <=> Trait) Java: Extends (Class => Class | Interface => Interface), Implements (Class => Interface), Auto-boxes (Primitive/value type => Class) Generics: Works mostly the same in both languages. In Java you have to deal with the side-effects of type-erasure from time to time, and there's also the `? extends Y` syntax, for which Rust has no counterpart. In Rust you can have a generic parameter which is a lifetime, for which Java has no counterpart. Again though, these lifetimes are only used by the borrow checker, unlike normal type parameters, they do not affect the generated code. Java appears simple because it is built on OOP concepts that are very familiar to most people. However, those OOP concepts contain a huge amount of complexity (inheritance trees, constructors, abstract classes, virtual/final methods, monitors, etc) and Rust simply gets rid of all of those concepts entirely. That's why I think it's simple.

wbl 7y ago

You don't think the type system is part of language semantics?

Tuna-Fish 7y ago
The borrow/lifetime system never changes the behavior of any program, the only thing it can do is to disallow some programs from compiling. This is not how the rest of the type system works. This means that it's possible to write a compiler that correctly compiles all correct rust programs without having a lifetime system at all. It also means that having the lifetime system in makes writing programs more complicated, but it makes reading them, and understanding what a program does, easier.
- wbl 7y ago
  Ownership is linear types. It's part of the type system.
  - Tuna-Fish 7y ago
    Yes, but borrowing isn't, and ownership is by itself no more complicated than RAII.
Diggsey 7y ago
The type system is yes, just not the borrow checker or the type checker. The type system is still relatively simple compared the type systems in Java/C#/C++/etc. Let's take Java's as an example because I think people regard it as being simple: Building blocks of the type system: Rust: Types, Traits Java: Primitive types, classes, interfaces, (value types yet?) Relationships between those building blocks: Rust: Implements (Type <=> Trait) Java: Extends (Class => Class | Interface => Interface), Implements (Class => Interface), Auto-boxes (Primitive/value type => Class) Generics: Works mostly the same in both languages. In Java you have to deal with the side-effects of type-erasure from time to time, and there's also the `? extends Y` syntax, for which Rust has no counterpart. In Rust you can have a generic parameter which is a lifetime, for which Java has no counterpart. Again though, these lifetimes are only used by the borrow checker, unlike normal type parameters, they do not affect the generated code. Java appears simple because it is built on OOP concepts that are very familiar to most people. However, those OOP concepts contain a huge amount of complexity (inheritance trees, constructors, abstract classes, virtual/final methods, monitors, etc) and Rust simply gets rid of all of those concepts entirely. That's why I think it's simple.