Reading "The #Rust Programming Language" Book 👀
So far?
- Shadowing same-scope variables – interesting 🤔
- Default immutability of variables and also references passed to functions – I like it 😯
- Implicit return values – nah thanks. *writes explicit return statement* 🤨
Oof, got past the Generics, Traits and Lifetimes chapter now @pixelspree 👀
I mean, it's an additional effort on coding, but makes garbage collection or manual (and error prone) destruction by the developer obsolete 💁🏼
@pixelspree Ok, I'm through 😀
I'd summarize the chapter about #OOP something like: #Rust is object oriented, but with very limited inheritance to what most people would expect 🤔💁🏼
Let's do the final exercise project 🤓
That feeling, if you have prepared a few unittests and bit by bit expand your actual code and they all just pass out of the box 😌
Two weeks went by, and I think I'm pretty far on having a small program for german #TribalWars players ready 👀
Would be cool having some experienced #Rust #developer have a code review of this thing then, how well (or bad 🤪 ) did coding wise.
One last thing missing, after that I just have to do some doc-commenting, readme and CI-pipeline stuff before I can push it
@9Lukas5 the return thing is done out of consistency with other expressions.
these are all expressions which evaluate to a value - even functions can be thought of this way (kinda)
let a = func();
let a = {
let b = 5;
b + 7
};
// a = 12
let a = if 5 > 1 {
8
} else {
0
};
// a = 8
let a = match Some(0) {
Some(_) => 6,
None => 9,
};
// a = 6
@laund I'm used to it, that this kind of expression is only done e.g. in Java Lambdas or similar in-function expressions, but not for the actual function return value 😅
Seems kind of strange, that just a missing semicolon on the last line makes a statement to an expression 🫢🤪
But yeah, it makes it consistent and most likely one will get used to it 💁🏼
Regarding implicit return values:
Almost everything is an expression in Rust, so you could write:
let foo = if condition {
do_something();
bar
} else {
baz
};
so `foo` will be assigned the value `bar` or `baz`.
See also: https://doc.rust-lang.org/rust-by-example/flow_control/if_else.html#ifelse
It becomes very natural to not use `return`. And believe me: you _will not_ get it wrong. The Rust compiler is very strict, so "accidentally" returning the wrong value won't happen.
@janriemer Out of curiosity I tried using an explicit 'return' in such an inline conditional assignment.
But an explicit 'return' statement will exit the function it is in, no matter how deep down it is placed in loops or conditions 🤪
@9Lukas5 Yes, explicit return are very good for early exiting a function, totally agree here.
If you want to dive in a little deeper:
Did you know that Rust has it's own operator for handling such control flow to make it more explicit!? 
Enum std::ops::ControlFlow
9Lukas5 🚂 🐧
Hagen Patzke
pixelspree
Signalabhängig
Martin Hoffmann
laund [moved]
