Announcement

Collapse
No announcement yet.

Rust 1.21 Released With Minor Updates

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • uid313
    replied
    Originally posted by veeableful View Post

    Impl is implement. A lot of things are abbreviated in other languages. int, bool, var, etc, func, ifdef, etc.. I think it's more consistent (like why in Java you say boolean for boolean but int for integer int or in js, why variable is var but function is function). Just my thoughts.
    Good point.
    I could guess "Impl" was short for Implement, but I still don't know what it does or what it means.
    Like is it a class, a interface or a trait or something else?

    I wish Rust was more like C, C++, C#, Java, and PHP and that it was less like Ruby.

    Leave a comment:


  • caligula
    replied
    Originally posted by Luke_Wolf View Post

    I don't really have a problem with Rust's syntax but that's overstating the case by far. There really isn't a reason that for example
    Code:
    fn foo(bar:i32) -> i32 {
    //stuff
    }
    is intrinsically any better than
    Code:
    i32 foo(i32 bar) {
    //stuff
    }
    at conveying the important information, it arguably looks prettier but there isn't some objective advantage to this..
    Try to express (i32 -> i32) -> (i32 -> i32) in C.

    Leave a comment:


  • jhenke
    replied
    I really think rust is an awful language because it has some big design flaws. First and foremost: The whole cargo nonsense. You really see it was developed by people coming from the JavaScript world. Instead of building interoperable system libraries, you have to write your own library for everything, even for shared libraries that you already have on your system. So just the basic system of rust + cargo already compiles a large amount of different libraries, each with it's own versioning. Together with the fact that they again reinvented the wheel of a package system (it is only the 3rd? 4th? package management I have to use?). Instead of writing one useful library, which covers a whole area of functions, you again have a library for each tiny piece of code. It is exactly a copy of the npm stupidity, just to "system development" now.

    Aside from that, why can't they use the system's LLVM libraries, when they are already installed. No, you have to recompile all of LLVM, even for processor architectures you never use.

    So Rust clearly looks like a hype-language by people trying to reinvent the wheel, because web is so modern and they refuse to learn from past mistakes.....

    Leave a comment:


  • Luke_Wolf
    replied
    Originally posted by mmstick View Post

    Every syntax choice has been made based on how well it can explicitly express the intent of the action being performed though. As a systems language, there's really no other syntax that would suitably convey all the information that Rust's syntax is currently conveying. After all, we spend more time reading code than writing it, so the less ambiguity in syntax, the better. About all you could change are which characters to convey what information.

    Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.
    I don't really have a problem with Rust's syntax but that's overstating the case by far. There really isn't a reason that for example
    Code:
    fn foo(bar:i32) -> i32 {
        //stuff
    }
    is intrinsically any better than
    Code:
    i32 foo(i32 bar) {
        //stuff
    }
    at conveying the important information, it arguably looks prettier but there isn't some objective advantage to this. Similarly anywhere else it breaks from C-Style syntax where features are equivalent. Obviously Rust enums, match expression, the way the impl/type system stuff works, and other rust specific features require their own special syntax, but it's just a bit much to declare Rust syntax the only way to go.
    Last edited by Luke_Wolf; 13 October 2017, 03:51 AM.

    Leave a comment:


  • audir8
    replied
    Rust is more functional, and if you've done any functional programming with Lisp, Haskell, Clojure, Scala, even Swift, Ruby or Python, you should be in friendly territory. I'm not sure I would call the Syntax Ruby-like. It seems closer to C++ with lambdas, and the let expression is similar to Haskell, so functional programming again.

    Leave a comment:


  • veeableful
    replied
    Originally posted by uid313 View Post

    Yes, I get that the typing system would need to be a bit different from what I am used to.
    Even so, I find the syntax a bit weird.
    I don't like the implicit returns. I like explicit return statements.
    Also I am not sure what a `impl` is, everything is abbreviated.
    Like is `impl` a class, trait or interface?
    Impl is implement. A lot of things are abbreviated in other languages. int, bool, var, etc, func, ifdef, etc.. I think it's more consistent (like why in Java you say boolean for boolean but int for integer int or in js, why variable is var but function is function). Just my thoughts.

    Leave a comment:


  • uid313
    replied
    Originally posted by mmstick View Post

    Every syntax choice has been made based on how well it can explicitly express the intent of the action being performed though. As a systems language, there's really no other syntax that would suitably convey all the information that Rust's syntax is currently conveying. After all, we spend more time reading code than writing it, so the less ambiguity in syntax, the better. About all you could change are which characters to convey what information.

    Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.
    Yes, I get that the typing system would need to be a bit different from what I am used to.
    Even so, I find the syntax a bit weird.
    I don't like the implicit returns. I like explicit return statements.
    Also I am not sure what a `impl` is, everything is abbreviated.
    Like is `impl` a class, trait or interface?

    Leave a comment:


  • mmstick
    replied
    For some insight on what the Rust community is doing at the moment, a lot of work is being put into the current impl period event.

    - Week 1 Newsletter
    - Week 2 Newsletter

    The major focuses at the moment are:

    1. Faster compile times & improved incremental compilation
    2. Finally implementing Non-Lexical Lifetimes
    3. Making Lifetimes easier to work with, in general
    4. Stabilizing SIMD support
    5. Improving bindgen
    6. Improving docs & stabilizing the most popular crates
    7. Various improvements to Rust's book, documentation, cargo, rustup, RLS, etc.
    8. Quickly pushing through and implementing accepted RFCs

    Overall, it's a very well-coordinated effort.

    Leave a comment:


  • Tomin
    replied
    Originally posted by mmstick View Post
    Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.
    I looked into what Ruby looks like and I must agree with this.

    Leave a comment:


  • mmstick
    replied
    Originally posted by uid313 View Post
    Rust technically seems amazing.
    It's just too bad about the ugly syntax. It looks way too much like Ruby, eww.
    Every syntax choice has been made based on how well it can explicitly express the intent of the action being performed though. As a systems language, there's really no other syntax that would suitably convey all the information that Rust's syntax is currently conveying. After all, we spend more time reading code than writing it, so the less ambiguity in syntax, the better. About all you could change are which characters to convey what information.

    Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.

    Leave a comment:

Working...
X