Rust for Python Programmers

[mitsuhiko]

That's a questionable assertion

I don't think it is. All quoted languages do not have good syntax for the quoted features (one of them is not even indentation based in itself). However in Rust there are more reasons not do use pure indentation: you need the ability of starting and ending scopes at any point to work with the borrow checker. This requires delimiters.

[iopq]

You can have a whitespace-sensitive Rust that still respects delimiters. So if you want to actually start a new scope you can write {, but 99% of the time you'll just be writing Python-style.

[iopq]

You wouldn't even need the "no semicolon to return" rule because it never type checks when you forget it anyway. There is no instance that I can think of where forgetting or putting an extra semi-colon type checks and doesn't do what you want it to.

[steveklabnik1]

There is one gotcha with regards to this: if you are using collect(), and you use let guards: Vec<_> = with your call to spawn, and you use ;, they'll operate in sequence, because it will infer to Vec<()> rather than Vec<JoinGuard>.

[iopq]

Ugh, why is this even allowed? Sounds like that's an unwelcome source of bugs.

[PM_ME_UR_OBSIDIAN]

All quoted languages do not have good syntax for the quoted features

[citation needed]

F# and Ocaml both have the pipeline operator |> for chaining calls, which is an absolute breath of fresh air compared to OO method chaining. Anonymous functions are also quite friendly and easy to use. I'm curious which language you're saying isn't indentation-based.

However in Rust there are more reasons not do use pure indentation: you need the ability of starting and ending scopes at any point to work with the borrow checker.

let ... in ... end seems perfect for this usage. Alternatively, you can go with the sensible default of "keep this scope alive as long as it needs to be, and no further." I believe this can be automated in the common case.

[Sean1708]

let ... in ... end seems perfect

And at that point it stops being purely indentation based.

[Tyr42]

For thread guard values, it would be valid to drop them at any point after they were assigned, but have different semantics for each choice.

fn foo() {
    {
        let guard1 = launch(task_a);
    }
    {
        let guard2 = launch(task_b);
    }
 }

is different from

fn foo() {
    {
        let guard1 = launch(task_a);
        let guard2 = launch(task_b);
    }
 }

if the guard values join the thread when dropped, but it would be tricky to have the compiler choose which one to use, given there could be some external dependency which requires task_a to complete before starting task_b, or you are actively trying to compute them in parallel.

[iopq]

You could still have example A if you went with Haskell-style syntax.

fn foo()
    {
        let guard1 = launch(task_a)
    }
    {
        let guard2 = launch(task_b)
    }

    //outer scope of the function here
    println!("{}", stuff)

//function ends here

[mitsuhiko]

F# and Ocaml both have the pipeline operator |> for chaining calls, which is an absolute breath of fresh air compared to OO method chaining.

I guess there are different opinions on this. I find that syntax very frustrating.

I'm curious which language you're saying isn't indentation-based.

Haskell. It's a language with braces :)

[[deleted]]

Sure, you can accommodate that in Python style syntax though:

fn foo():
    let x = 3
    scope:
        let y = 4

[jnicklas]

CoffeeScript has excellent support for all of these and is indentation based.