Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

A half-hour to learn Rust

fasterthanli.me

Post reply on HN
Print view View original

71–80 of 150 posts

Re: A half-hour to learn Rust

#71

Post by fasterthanlime »

kzrdude wrote: post #36
fasterthanlime wrote: post #29

Earlier quoted context omitted.

I debated which terminology to use and thought "throwing away" was more intuitive, especially if you've never heard of "binding" before. It has its limits though - in your example I'd say you're throwing away the result of evaluating "x", just as if you did: x;

I don't agree, because we can try the two following programs, and one of them does not compile. It compiles with underscore. 1: let x = String::new(); let _ = x; println!("{}", x); 2: let x = String::new(); x; println!("{}", x); // ERROR: Use of moved value x. And this is why I said that let _ = x; is a no-op. :)

Huh, TIL! Had no idea `x;` actually moved `x`.

Re: A half-hour to learn Rust

#72

Post by jstimpfle »

dmit wrote: post #45
gameswithgo wrote: post #40

Earlier quoted context omitted.

The C approach makes the compiler much more complex, and introduces extra typing in other language constructs. (like parens around if statements) This is why many newer languages do something more like the Rust way. Overall it is simpler for programmer and compiler.

Pretty much. The mere existence of cdecl(1) says a lot about the simplicity of C's type declaration syntax.

It's unfortunate that the simple (and easy) underlying principles are not well known. See my other comment.

The bigger reason why recent languages have different declaration syntax is to avoid the need to carry a symbol table during parsing, and to avoid the need to parse all files serially instead of independently. Because to recognize a declaration the parser has to know which words correspond to types in the current scope.

Re: A half-hour to learn Rust

#74

Post by isoprophlex »

jerf wrote: post #55
whatshisface wrote: post #53

Earlier quoted context omitted.

The dust is settled and the fight is over. Which monad tutorial won "best monad tutorial?"

None of them. The concept is fundamentally flawed. It's as if everything you ever read about C was all about bitwise manipulation operations, on and on and on about bitwise manipulation, to the point not-C programmers think the language is primarily about bitwise manipulation and people start porting bizarre misunderstandings of bitwise manipulation into other languages and claiming they're just like C now, when it's…

However, the c community never felt like going on and on and on about bitwise manipulation... Anyone have any idea why people get so hung up about explaining monads?

Re: A half-hour to learn Rust

#75

Post by fasterthanlime »

jstimpfle wrote: post #28
fasterthanlime wrote: post #20

Earlier quoted context omitted.

How do you feel about C's function pointer syntax?

To be pedantic, there is no (specialized) function pointer syntax. The syntax to declare function pointers is just general declaration syntax, which in turn is basically regular expression syntax. How to declare a function pointer is hard to grok when not being introduced to declaring variables in a principled way. But it makes sense and is not too clunky if you're only declaring a function pointer every now and then…

Exactly! C is internally consistent in that, for example, the star in:

  int *a;
is part of the variable declaration, not the type. And the function pointer syntax derives from that. (I know you know, just providing context).

However, just because it's consistent doesn't mean it's easy to remember or use. Just repeating "it's easy!" doesn't make it true. Others have brought up that cdecl exists, which illustrates this pretty well.

It seems you've worked with this syntax for long enough, and it fits your way of thinking well enough, that it's not an issue at all for you! But there's ample evidence of a lot of people struggling with it, which should be sufficient to deem it "not easy".

Re: A half-hour to learn Rust

#76

Post by jstimpfle »

fluffything wrote: post #49
jokoon wrote: post #12

> let x: i32 = 42; I'm sorry but this notation will always make me scream. C is so much simple: int x = 42; not "let", no colon, and no ambiguous "i32 = 42"

C is the opposite of simple. If you want to create a binding in C, you need to learn multiple, unnecessarily complex rules. Sure, creating a binding to an int is easy: int foo = 42; but doing the same thing for pointers to arrays or function pointers is not: void( foo)(int) = bar; // function pointer int ( foo)[N] = baz; // pointer to array OTOH in Rust you just need to learn one rule: bindings are created with the g…

But that's just not true. There is a single principled way for C declarations, and it's as easy as "a binding is a type name followed by an expression and a semicolon".

And while small inconcistencies have been introduced over time, it was entirely consistent when C was conceived. The problem is just that the simple rule how to read declarations is not well-known (I don't understand why). See my other comments.

Re: A half-hour to learn Rust

#77

Post by jstimpfle »

fasterthanlime wrote: post #75
jstimpfle wrote: post #28

Earlier quoted context omitted.

To be pedantic, there is no (specialized) function pointer syntax. The syntax to declare function pointers is just general declaration syntax, which in turn is basically regular expression syntax. How to declare a function pointer is hard to grok when not being introduced to declaring variables in a principled way. But it makes sense and is not too clunky if you're only declaring a function pointer every now and then…

Exactly! C is internally consistent in that, for example, the star in: int *a; is part of the variable declaration, not the type. And the function pointer syntax derives from that. (I know you know, just providing context). However, just because it's consistent doesn't mean it's easy to remember or use. Just repeating "it's easy!" doesn't make it true. Others have brought up that cdecl exists, which illustrates this…

I can understand why newer languages have moved away from this style of declaration syntax, and moving away has brought merits such as becoming more intuitive to understand to novices, as well as better support for tooling / IDEs, including parsing performance gains.

On the other hand, nothing is quite so easy to read and write for me as the terse C declaration syntax (granted I don't declare a lot of pointers-to-functions-returning-pointers-to-functions).

Re: A half-hour to learn Rust

#78

Post by jstimpfle »

gameswithgo wrote: post #40
jokoon wrote: post #12

> let x: i32 = 42; I'm sorry but this notation will always make me scream. C is so much simple: int x = 42; not "let", no colon, and no ambiguous "i32 = 42"

The C approach makes the compiler much more complex, and introduces extra typing in other language constructs. (like parens around if statements) This is why many newer languages do something more like the Rust way. Overall it is simpler for programmer and compiler.

I don't think parentheses around if-conditions are related to C variable declarations (if that's what you were saying), and I think it's fair to say that C's syntactical terseness is unmatched.

The parentheses are required to separate the condition from the following conditional statement.

Re: A half-hour to learn Rust

#79

Post by AnimalMuppet »

fasterthanlime wrote: post #71
kzrdude wrote: post #36

Earlier quoted context omitted.

I don't agree, because we can try the two following programs, and one of them does not compile. It compiles with underscore. 1: let x = String::new(); let _ = x; println!("{}", x); 2: let x = String::new(); x; println!("{}", x); // ERROR: Use of moved value x. And this is why I said that let _ = x; is a no-op. :)

Huh, TIL! Had no idea `x;` actually moved `x`.

But where is it moved to? Who owns it now? Or is it just lost?

Re: A half-hour to learn Rust

#80

Post by nobleach »

galfarragem wrote: post #62
talkingtab wrote: post #50

This is the most useful introduction to a language I have ever read. Often language introductions produce a "Wall of Complexity" and I failed in my last two attempts learning Rust failed because of that. This is just great. Be warned, the "half hour" part is probably a bit like "99 cents" as a price tag. I've already spent more than that, but it is time well spent. Thanks for writing this!

You might like this: https://learnxinyminutes.com

I also like Derek Banas videos (https://www.youtube.com/channel/UCwRXb5dUK4cvsHbx-rGzSgw) for this same quality. He doesn't do many "deep dives" into the languages, but he does a fantastic job getting your feet wet with very common tasks... much like these learnxinyminutes pages do.
Post reply on HN