News for hackers. Stuff that matters.
Re:Introducing Rust Language Server by hetman on Tuesday October 18, 2016 @07:41PM (#12739728)
I think the most astonishing thing to me about the Rust language project is not the language it self (sure it's innovative but there's also still a lot of work to be done to make it get out of your way). It's the speed and tenacity with which the project has managed to push development of the supporting tooling. The development tools surrounding a language can often be more important for productivity than the language itself, and it feels like the Rust team and community really get that.
Re:Introducing Rust Language Server by JoshTriplett on Tuesday October 18, 2016 @07:49PM (#12739768)
I think that's a side effect of making a welcoming community a priority. The Rust Language Server grew out of feedback from the Rust Language Survey, in which many people responded that they wanted good IDE support.

That isn't a glamorous task to work on, especially if you're already comfortable with the level of editor support you have, but it helps bring more people into the community, which has a multiplicative effect.

Re:Introducing Rust Language Server by allengeorge on Tuesday October 18, 2016 @10:06PM (#12740440)
I can't upvote this enough. I found the Rust community incredibly welcoming, and loved the focus on tooling - making our day-to-day lives so much better. So much so, that after a few weeks of working with Rust I contributed a few small fixes to the IntelliJ Rust plugin.

So, yeah - the community inspired me, and I hope the RLS inspires other people to contribute to Rust and the tooling around it as well!

Re:Introducing Rust Language Server by theossuary on Tuesday October 18, 2016 @08:05PM (#12739840)
I think it's a side effect of having a punishing language. Coding Rust is always described as fighting with the compiler, I don't think Rust would have ever taken off if there weren't great tools to fight the compiler with. I think that's a part of it, anyway.
Re:Introducing Rust Language Server by fabrice_d on Tuesday October 18, 2016 @08:15PM (#12739882)
I don't think "fighting the compiler" is an accurate description of the Rust coding experience. There is a learning curve during which you feel like you fight the borrow checker a lot, but once you get it you will find that the compiler is actually helpful.
Re:Introducing Rust Language Server by iopq on Wednesday October 19, 2016 @05:54AM (#12742429)
There's plenty of fighting the compiler.

    error[E0281]: type mismatch: the type `fn(_) -> _ {tool::second::<_>}` implements the trait `std::ops::FnMut<(_,)>`, but the trait `for<'r> std::ops::FnMut<(&'r _,)>` is required (expected concrete lifetime, found bound lifetime parameter )

     --> src\lib.rs:53:11
       |
    53 |            .filter(apply(second, i))
       |                    ^^^^^
       |
       = note: required by `apply`

    error[E0271]: type mismatch resolving `for<'r> <fn(_) -> _ {tool::second::<_>} as std::ops::FnOnce<(&'r _,)>>::Output == _`
      --> src\lib.rs:53:11
       |
    53 |            .filter(apply(second, i))
       |                    ^^^^^ expected bound lifetime parameter , found concrete lifetime
       |
       = note: concrete lifetime that was found is lifetime '_#11r
       = note: required by `apply`

    error: aborting due to 2 previous errors
I now know why I'm getting this error. Would you?
Re:Introducing Rust Language Server by pcwalton on Wednesday October 19, 2016 @12:12PM (#12745088)
That's a bad error message. Please file a bug :)

It sounds like you're returning closures, which is a very recent feature—it only became possible last month with the implementation of "impl Trait" IIRC. It takes time for features to mature.

Re:Introducing Rust Language Server by iopq on Thursday October 20, 2016 @02:33AM (#12750136)
Re:Introducing Rust Language Server by lmm on Wednesday October 19, 2016 @09:55AM (#12743750)
I suspect I would - I'll happily guess if I can take a look at the code (or at least the signatures of "filter", "apply", "second" and "i").
Re:Introducing Rust Language Server by iopq on Thursday October 20, 2016 @12:24AM (#12749720)
`i` is just getting closed over, it's an integer

filter is from the standard lib

apply is defined as

    fn apply<A, B, C, F, G>(mut f: F, a: A) -> impl FnMut(&B) -> C
         where F: FnMut(&B) -> G,
               G: FnMut(A) -> C,
               A: Clone
    {
        move |b| f(b)(a.clone())
    }

second comes from

https://github.com/Stebalien/tool-rs/blob/master/src/sequenc... which means you have to track down its implementation somewhere in macros

Re:Introducing Rust Language Server by iopq on Thursday October 20, 2016 @02:23AM (#12750101)
I put the whole code in a separate branch for you:

https://bitbucket.org/iopq/fizzbuzz-in-rust/src/920bd2bd1267...

this doesn't work, so I want you to tell me why

Re:Introducing Rust Language Server by lmm on Thursday October 20, 2016 @07:17AM (#12751336)
Hmm fair enough, harder than I thought (I don't know Rust, the error just sounded sensible). It reads like the function you're passing into filter is supposed to be "lifetime-generic" taking a parameter whose lifetime comes from the for, but the function returned by apply has a fixed lifetime. But I can't see where it's getting the lifetime for that from, or what to do about it. I guess at that point I'd try adding an explicit lifetime to the return type of apply (or maybe an IDE could show it without having to write it)?
Re:Introducing Rust Language Server by iopq on Thursday October 20, 2016 @05:52PM (#12756509)
The problem is with the function `second` that I get from the other crate. If I replace the `second` function with my own implementation it works. But for the `second` implementation from tool.rs to work, Rust needs better higher ranked lifetime support.

It would also work with a closure, but I wrote my code this way to avoid closures in the first place (I was going for point-free style).

I basically just have to write my own function:

https://bitbucket.org/iopq/fizzbuzz-in-rust/src/58bfa4c58c80...

this compiles, but it seems kind of pointless since I can only use this particular function in my case (because of the extra levels of references)

if I could use the tool.rs version, it would automatically generate all the implementations I need using macros

Re:Introducing Rust Language Server by iopq on Sunday October 23, 2016 @09:33PM (#12776306)
Someone helped me with it:

I had to change the `apply` function to dereference as well, that way it doesn't run into the lifetime issue. It has something to do with higher ranked lifetimes (the inability to express the higher ranked lifetime)

This is the working version:

https://bitbucket.org/iopq/fizzbuzz-in-rust/src/95451868e27f...

Re:Introducing Rust Language Server by vertex-four on Wednesday October 19, 2016 @06:20AM (#12742532)
Closure-related error messages are not one of the strong points of Rust so far, unfortunately.
Re:Introducing Rust Language Server by annnnd on Wednesday October 19, 2016 @07:43AM (#12742911)
Either that, or the Stockholm sindrom kicks in after a while. :)
Re:Introducing Rust Language Server by duaneb on Tuesday October 18, 2016 @08:35PM (#12739974)
Agreed.

Refactoring tools would help address compiler concerns quicker, however.

Re:Introducing Rust Language Server by kbenson on Tuesday October 18, 2016 @09:07PM (#12740146)
> I think it's a side effect of having a punishing language.

Rust is a punishing language in the same way a notifying spell checker is a punishing tool. For someone used to writing without stopping and reviewing at the end, spell checking as you go might at first be annoying. After a while, you integrate it into your style, and choose the best time to deal with the errors when they come up yourself, whether that be immediately, after the paragraph/idea is expressed, or at the very end. In any case, having those handy notifications of what you need to fix is useful for a good 90% or more of the problems you might encounter.

Re:Introducing Rust Language Server by adamnemecek on Tuesday October 18, 2016 @10:03PM (#12740431)
Its not punishing, it's helping. Fixing bugs in development sure beats fixing bugs in production. And most of the things it complains about are in fact bugs.
Re:Introducing Rust Language Server by szemet on Wednesday October 19, 2016 @12:42AM (#12741129)
I agree. At least for me it was a common pattern that by fixing a bug I've introduced another (sometimes suprising one), and by fixing that I've introduced another and so on. I would have given it up without strong editor support giving hints on the fly.

(I don't remember similar experiences learning other languages even with strong static checks (e.g. haskell). Either my errors were 1 level deep there, or the propagation of errors (like changing a type somewhere) was easier to follow/predict to me)

Re:Introducing Rust Language Server by jimbokun on Tuesday October 18, 2016 @09:37PM (#12740302)
Not a Rust developer, but this project sounds sexy to me! :)

I use Emacs as much as possible, but for Java dev use IntelliJ because the Java plugins I've tried were always relatively clunky. Having great language support regardless of editor sounds wonderful!

Re:Introducing Rust Language Server by wst_ on Tuesday October 18, 2016 @10:22PM (#12740507)
You can develop Rust with IntelliJ as well. There's a plugin out there.
Re:Introducing Rust Language Server by sjm on Wednesday October 19, 2016 @12:04AM (#12740986)
I think he's saying he'd rather use Emacs for Java dev, but IntelliJ is a necessary evil. For Rust, there's https://github.com/racer-rust/emacs-racer which seems pretty solid.

P.S. Regarding Java dev on Emacs, ENSIME (http://ensime.github.io) now works with java-mode rather than only Scala. I use it for Android development, and it's not perfect but works well enough.

Re:Introducing Rust Language Server by steveklabnik on Tuesday October 18, 2016 @10:32PM (#12740545)
They gave it a snazzy site: https://intellij-rust.github.io/

One really interesting thing about this effort is that the IntelliJ folks have their own stuff for autocomplete; they're not using racer.

Re:Introducing Rust Language Server by xorxornop on Wednesday October 19, 2016 @03:44AM (#12741862)
Yeah, that seems nearly a constant for them. For example, in ReSharper (and presumably Project Rider), despite C# having the excellent, very fast (and, critically, fully open source!) compiler-as-a-service, Roslyn, they continue to use their own internal compiler service for code autocompletion, refactoring, and correctness analysis.
Re:Introducing Rust Language Server by royjacobs on Wednesday October 19, 2016 @05:50AM (#12742414)
Resharper has been in development far longer than Roslyn and seems to be much more suited to working with partially incorrect code (the kind you have while typing away) and incremental changes.

Does Roslyn have the same support?

Re:Introducing Rust Language Server by drchickensalad on Wednesday October 19, 2016 @06:19AM (#12742529)
Roslyn is built for incomplete/flawed code
Re:Introducing Rust Language Server by royjacobs on Wednesday October 19, 2016 @07:07AM (#12742731)
Ah, excellent!

I guess JetBrains is heavily invested in ReSharper (and the underlying AST code) which would explain why they won't want to switch right away, if at all.

Re:Introducing Rust Language Server by aswanson on Wednesday October 19, 2016 @12:57PM (#12745467)
I really wish I had time to contribute to this language. The community seems awesome.
Re:Introducing Rust Language Server by xuejie on Tuesday October 18, 2016 @09:02PM (#12740116)
I might be wrong but one possible explanation is that the language is so hard to learn that people would need tools to help in the beginning.

Within Mozilla, they can use servo as a selling point or turn to creators for help, but from the outside world, we've got so many languages available, while some might not be good when the software grow big, they are more beginner-friendly than Rust. Hence Rust needs all those tooling from the very start.

Re:Introducing Rust Language Server by steveklabnik on Tuesday October 18, 2016 @09:07PM (#12740142)
We've actually heard from production users over the last year or two that the compiler itself helps you learn the language; it's been compared to a pair at times. And that was long before new errors...

That said, there are more tools to be built to make it even better. https://internals.rust-lang.org/t/borrow-visualizer-for-the-... is one extension I'm very interested in seeing.

Re:Introducing Rust Language Server by xuejie on Tuesday October 18, 2016 @09:21PM (#12740219)
I definitely agree! While I was reading about Rust couple of weeks ago I was thinking maybe exposing the compiler's detail would help refactoring and diagnosing bugs here. It's so awesome that you guys have already think of this! Really awesome work!

Again, just want to mention that my point is simply that Rust needs more tooling to overcome its learning hurdles, and to me this is not a bad thing. Because once we have tools solving the learning curve problem, we can enjoy all the benefits Rust provides :)

Re:Introducing Rust Language Server by steveklabnik on Tuesday October 18, 2016 @09:35PM (#12740287)
For sure; the curve can always be lower. :)
Re:Introducing Rust Language Server by pjmlp on Wednesday October 19, 2016 @03:21AM (#12741766)
The borrow visualizer idea is great!

It would help a lot in regards to language productivity.

Re:Introducing Rust Language Server by imh on Tuesday October 18, 2016 @09:32PM (#12740269)
I don't know. I love haskell, but it fits the bill of a language so hard to learn that people need tools to help in the beginning. Yet haskell tooling isn't that great. I'd guess that it's a question of priorities.
Re:Introducing Rust Language Server by wtallis on Tuesday October 18, 2016 @11:14PM (#12740757)
I suspect haskell might be in a difficulty class beyond rust, where really good tooling still wouldn't be enough to make it significantly more accessible. The things rust requires a C++ programmer to learn also seem to be relatively amenable to mechanical assistance.
Re:Introducing Rust Language Server by iopq on Wednesday October 19, 2016 @06:00AM (#12742446)
Writing Rust code is more difficult than writing Haskell code. Haskell is more than okay with taking a performance hit for convenience. Rust APIs actually have you pass in references to buffers where you want your data to end up. Rust doesn't use GC and tries to focus on pay-as-you-use abstractions. That's a lot more control, but also more verbosity.
Re:Introducing Rust Language Server by imh on Wednesday October 19, 2016 @12:08AM (#12741000)
If haskell is that much harder, it should benefit from better tooling that much more. I think there really is a big difference in the priorities. I've never played around with GHC, so I have no idea how hard tooling is, but I know some good old humans are at least able to contribute (https://izbicki.me/blog/error-messages-in-ghc-vs-g%2B%2B.htm...).

edit: It looks like the error message changes may have been reverted (https://phabricator.haskell.org/rGHC92c924e07dfef327509555c2...) :( Sad that they reverted it instead of fixed it.

Re:Introducing Rust Language Server by leshow on Tuesday October 18, 2016 @09:04PM (#12740126)
It's really not that hard. I think it depends where you are approaching it from.
Re:Introducing Rust Language Server by kibwen on Tuesday October 18, 2016 @11:12PM (#12740743)
I agree that it depends on where you approach it from (my very first question for tutoring any new Rust user is "what languages have you used previously?"), but I'm afraid that saying "it's really not that hard" glosses over the experience of a large number of potential users. I don't consider Rust to be a particularly complex language--I put it on par with Python--but unlike Python the learning curve for Rust is remarkably steep, which is enough for me to classify Rust as a hard language to learn.

A foreknowledge of pointers helps, but for anyone for whom Rust is their first systems language, it's going to be Rust's task to teach them e.g. the stack/heap distinction, or what "aliasing" means, or why there are two string types (let's hope they're already versed in Unicode...), or how to design a system in the absence of pure OO.

Re:Introducing Rust Language Server by iopq on Wednesday October 19, 2016 @06:05AM (#12742470)
> I don't consider Rust to be a particularly complex language > I put it on par with Python

Python doesn't have complicated lifetime errors, confusing trait not being satisfied errors. Python function declarations don't need three lines of code.

I mean wtf is this?

    fn accumulate<'a, T: Monoid>(tuples: &[(&'a str, &Fn(i32) -> bool)], i: i32) -> Option<T>
        where T: From<&'a str>
there's about ten language features in these lines of code that Python doesn't have
Re:Introducing Rust Language Server by kibwen on Wednesday October 19, 2016 @01:13PM (#12745616)
I consider "complexity" to refer to both the quantity of language features and the number of significant or surprising interactions that exist between every language feature. Rust and Python are both medium-complexity languages, but the difference is that in Python you can totally ignore e.g. generators or decorators or (oh god) metaclasses and still get work done. In Rust you really can't get work done until you understand references and move semantics. The total height of each learning curve is the same, but Rust's is more like a cliff than a gentle slope, which is why it's crucial that we put so much focus on documentation.
Re:Introducing Rust Language Server by iopq on Thursday October 20, 2016 @02:32AM (#12750130)
I ran into higher rank lifetimes while trying to use a library in my program. You can totally pass closures around in a dynamic language like JavaScript without any issues (you just pay for it in performance). In Rust `-> impl Trait` is a new feature so it's still not at all polished.

I would argue that Rust has a higher learning curve overall than any dynamic language because of its type system.

Re:Introducing Rust Language Server by fredsir on Wednesday October 19, 2016 @08:00AM (#12742992)
I only have very little Rust experience, and would like to hear from a Rust veteran - as much as one can be - if that is considered good Rust, or if it's just an example of how bad Rust can be if you don't know what you're doing, or are trying to showcase bad Rust.

I would think it's the latter, but I don't know, to be honest.

Re:Introducing Rust Language Server by fiedzia on Wednesday October 19, 2016 @02:52PM (#12746588)
Its non-trivial and it could be written simpler (the tuples part could get its own type alias, making it more readable and shorter), but its not particularly bad or good.

You will find examples of this mostly in libraries, but rarely its something a beginner would write. You can actually do a lot without ever using lifetimes. Eventually you'll need to learn to read this though, and its just a matter of getting used to it. I'd say none of those is any harder to understand then let say nested list comprehension in python.

Re:Introducing Rust Language Server by Manishearth on Wednesday October 19, 2016 @09:12AM (#12743420)
It's basically an example of what happens when you try to use Haskell concepts in Rust; the type parameters explode quickly. Most rust functions are not like that. Some are. It's not exactly bad rust to have functions like that, but such functions should probably be uncommon in your codebase.
Re:Introducing Rust Language Server by iopq on Wednesday October 19, 2016 @09:27AM (#12743548)
Note that Monoid here is ONLY for the reason that Cow<str> doesn't satisfy Add. In fact, String doesn't satisfy it either. So I need to have a trait that allows me to call a function that concatenates my types. I already wrote how to concatenate Strings and Cow<str>s in my Monoid crate so I'm just re-using that.

It could be T: Concatenable for all I care, but the rest of the function needs to look this way, more or less.

I only have one type parameter, that's very common. I'm abstracting over String and Cow<str> because I want to bench the performance of both. (Cow<str> is always faster)

Re:Introducing Rust Language Server by Manishearth on Wednesday October 19, 2016 @09:56AM (#12743757)
I'm not just talking about Monoid, I'm talking about the overall signature -- with the Fn and the abstractions it's very Haskelly. Such functions are not common in Rust. You find them (all the iterator adaptors, for one), and they can be "good Rust", but they're not common. Which is okay.

(I don't disagree that Rust is more complicated than Python, just addressing GP's comment whether or not this is "good" rust.)

Re:Introducing Rust Language Server by iopq on Thursday October 20, 2016 @12:21AM (#12749713)
It's actually very common to pass around hashmaps of functions in dynamic languages. If anything, since you don't even have to know how they're implemented it's easier. I realize that my function incurs a run time cost because I'm making an array of trait objects. When I'm writing JavaScript I don't know and I don't care.
Re:Introducing Rust Language Server by iopq on Wednesday October 19, 2016 @08:38AM (#12743187)
You could write <'a, T: Monoid + From<&'a str>> and omit the where clause, but that seems even less readable to me. The rest basically has to be there for the function to do what it does.
Re:Introducing Rust Language Server by pcwalton on Wednesday October 19, 2016 @12:17PM (#12745128)
I don't agree with kibwen about Rust being just as simple as Python, but I also think it's a bit of a pointless comparison, given that Python is dynamically typed and Rust is statically typed. Any type system feature is something that Python trivially doesn't have.
Re:Introducing Rust Language Server by pjmlp on Wednesday October 19, 2016 @05:31AM (#12742348)
Regarding pointers, I think a good way would be to teach them both visually and without many C style tricks.

C style pointer tricks are better left for level two, so to speak.

Probably a good approach teach Rust's OO way is to introduce traits as kind of extensible modules that can be composed and go from there.

It is not 100% correct, but I guess it is easier to teach than going full theory with traits being a kind of type classes and do on.

Re:Introducing Rust Language Server by xuejie on Tuesday October 18, 2016 @09:18PM (#12740203)
I actually agree, it's not that hard, yes one can definitely grasp that with some efforts. But my point really is: the time from start learning Rust till when you can deliver your project is definitely longer than many other languages out there. So Rust needs more tooling than many other languages out there, which is not a bad thing considering all the merits in Rust. That's why we are seeing tooling growing very rapidly in this space.
Re:Introducing Rust Language Server by mgattozzi on Tuesday October 18, 2016 @09:33PM (#12740271)
I think it's more because we like making development easier and having tools to do that is great because it means I can spend more time with the compiler telling me I coded something wrong.
Re:Introducing Rust Language Server by mycall on Tuesday October 18, 2016 @09:51PM (#12740367)
It would be great if Rust Language Server supports Language Server Protocol.
Re:Introducing Rust Language Server by steveklabnik on Tuesday October 18, 2016 @09:54PM (#12740384)
(As mentioned below, it's the default protocol it uses)
Re:Introducing Rust Language Server by seangrogg on Tuesday October 18, 2016 @08:53PM (#12740078)
In two years there will be too many tools and people will start complaining of Rust fatigue, don't worry.
Re:Introducing Rust Language Server by rubber_duck on Wednesday October 19, 2016 @04:33AM (#12742091)
>It's the speed and tenacity with which the project has managed to push development of the supporting tooling.

Compared to what ? Community designed languages like D, Nim, w/e - no dispute here. But corporately backed languages such as C#, F#, Swift, TypeScript, Kotlin - not really. I guess it's fair since Rust is middle ground - sponsored by Mozilla but not getting the level of investment as the others mentioned.

Re:Introducing Rust Language Server by rkangel on Wednesday October 19, 2016 @04:40AM (#12742123)
I think that's the point. Lots of community languages leave the tooling to the community, which only works if your language gets adopted (and doesn't help it to get adopted).

Rust is a community language (admittedly with the organisational backing of Mozilla), but is driving the whole ecosystem.