List comprehensions were initially syntax for loops over generators. The current version introduces another variable scope.
alist = [foo(x) for x in things if isok(x)]
is equivalent to alist = []
for x in things:
if isok(x):
alist.append(foo(x))
Similarly it's not hard to explain what an @login_required or a @memoize decorator does, although it is tricky to write a decorator yourself. Same goes for generators.I don't think syntactic sugar is a bad thing. I wish C++ had better syntax. If I could never type hash_map<blah, blah>::iterator ever again, I would be happy. But that isn't the sort of feature that C++ tends to add.
2. Why do you thing that list comprehensions are so difficuilt to learn? iterators, generators and list comprehensions are easy and clean concepts.
If you want a feature, you write a lib. Once the feature is widely deployed it becomes a recognized pattern, so why not to include this one into the language?
Look at lambda or bind in boost - they are scary, but people still use them, since it's a powerful concept, and it would be much better to include them into the language.
If you're a python expert, clearly your answer is "yes! this is a great feature!". But that's what the C++ experts say too, even as their language buries itself under a mountain of complexity. From the outside looking in, I'm seeing exactly the same thing happen to python.
Some fancy features make a language fun and productive. Too many such features make it a mess.