In my quest to master Rust, I'm building a (toy) Soulseek client in Rust. Souleek is an old (2001) closed-source p2p network still used to share underground music.

For learning purposes, I'm imposing the following restrictions:

- I can't use external dependencies (crates)

- I have to reverse engineer the Soulseek protocol myself

So far it's been a lot of fun and rewarding as it touches upon low-level concepts I don't have to deal with normally as a web dev.

It's actually nice that it does not matter if it's a function or attribute that your calling in ruby. Check out the Uniform access principle (https://en.wikipedia.org/wiki/Uniform_access_principle).

When used correctly you can write IMHO really clean and concise OOP code where (cascading) changes are easily made.

Where this kills me is ambiguous commas.

    something = [ alpha beta, gamma ]

I have no idea if I just invoked alpha(beta, gamma) and put the result into a single-member array, or if I've got an array with two elements - alpha(beta) and gamma.

Yep you can create ambiguous nasty code like this. It's is clearly not expressing intent, so you would add parentheses.

It's not actually ambiguous; though it is a bit of language-specific syntax to learn.

Agreed. It is the "idiomatic" way of writing code in Ruby. I love Java but writing lambda expressions in Java with deeply nested parenthesis makes the code really ugly and less readable esp with chaining.

As far as I understand, Ruby style is writing the code in the most elegant way to increase readability and (hopefully) reduce chances of bugs.

So what would you expect my example above do, at a glance?

Or is my example something that a good Ruby developer never write at all?

It's not ambiguous to the computer, but it is ambiguous to a human at a glance.