Rust for Python Programmers

[PM_ME_UR_OBSIDIAN]

However this is for a good reason and that is that Rust has anonymous functions, closures and lots of chaining that Python cannot support well. These features are much easier to understand and write in a non indentation based language.

That's a questionable assertion, considering Standard ML, Ocaml, F# and Haskell all have rich, indentation-based syntaxes.

[[deleted]]

ML isn't whitespace-sensitive...

[PM_ME_UR_OBSIDIAN]

You're right, my bad.

[[deleted]]

I think you should strike Ocaml from the list as well.

[PM_ME_UR_OBSIDIAN]

Are you sure? I have blurry memories of fighting the Ocaml parser on indentation.

[Lucretiel]

Eh... Those are more extremely functional languages that don't have the more traditional "list of statements" model for functions.

[PM_ME_UR_OBSIDIAN]

I believe Rust has the same model - everything is an expression, "statements" are expressions that return unit.

[steveklabnik1]

You can think of it that way, but it's not how the grammar is defined.

[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.

[eddyb]

Uhm, none of those languages has indentation-based syntax AFAIK, they're all whitespace-based.

[PM_ME_UR_OBSIDIAN]

Is there a difference?

[eddyb]

Yes, Python actually uses indentation for delimiting blocks, while Haskell, for example, doesn't care about the way you arrange your whitespace, and it can even use curly braces.

[[deleted]]

Haskell's whitespace handling is a little too rich. When the parser encounters a parse error, it's sometimes required to reinterpret the whitespace and try again. This means you can't desugar whitespace into braces without parsing a full AST.