Guardians "Open Platform" Uses Scala

Well, I don't think your example is ideal, given that the "<-" is not really an API thing, but one of Scala's few "real" keywords as far as i know.

Considering that most people don't even use that for-loop, but prefer the possibilities of the collection API instead, I have to wonder:

When I would have to look up how Pythons for loop works, how would i do that? Considering I have a collection how would I even discover that I have the possibility to loop through it?

In Scala this is quite obvious, consider the following example:

<code>

val collection = List(1,2,3,4,5)

collection foreach prinltn

<i> => Prints each number to a new line.</i>

</code>

Basically this is a method of the collection, which can be shown by an IDE or a commandline tool, like all other methods.

So instead of using some custom handcrafted control syntax, just use the possibilities of the libraries.

Instead of using some imperative multi-line code to do a simple thing, you can use Scala's functions of higher order and be done on the same line you started. (I'm wondering why Python has some functional methods (filter, map, reduce), but didn't add them to the collection. Why they force people to use a different syntax for it is beyond me.)

So speaking of cryptic things: Would you agree to remove things like [1,2,3], set([1,2,3]) or {'foo' : 1, 'bar' : 2} from Python?

In my opinion this is far more worse than any "cryptic" method names. There is no way an IDE or another tool can help you here. In more regular languages can write down "List", "Set" or "Map" and then look at the description and the available methods.

Regarding consistent code and a good API design, just look for instance at Python's list again:

Some things use angle brackets, like the list constructor ([1,2,3]), the selection of an item of the list (l[1], slicing the list (l[1:3]).

Some things use <element> <some words> <list>, like the Python contains method and it's negation ("in" / "not in").

Some things use <list> <operator> <element>, some <method>(<list>).

I wouldn't call that consistent or a good API, it's more a bunch of things happily slapped together. This wouldn't be bad at all, if we wouldn't have had enough languages doing this already. But I guess everyone can live with that.

I just personally prefer Scala's way to have an object, its methods and maybe arguments: it's always this way and only this way. No need to learn some special syntax or anything. If I have a question, I look at the methods.

I think everything can be seen from different viewpoints. Maybe there will be some alternative parser in the future, which allows people to program Scala with a Python-like syntax! I would love that.