As a guy who has worked with both Python and JavaScript for years, and has studied many many languages and is making his own programming language, I will throw my opinions on this:
1. For anonymous functions, both your examples for JavaScript and Python are what I call abusing anonymous functions. If a function is complex and has many different parts, then define a proper function and name it, give people a clue what the function does. However, if the function is so small anyone can understand what it does with just a quick look, then it's fine to define it as an anonymous function. Yes, chaining anonymous functions like you did is cool and all, but it reduces readability and that in turn reduces maintainability, we're not code golfing.
2. I get your point on chaining maps in Python, and I prefer how JS does it, but one might say the way Python does it is more "functional". Also, it honestly isn't difficult to write a small wrapper to enable chaining:
```
class Iter:
def __init__(self, arr):
self.arr = arr
def map(self, fn):
arr = map(fn, self.arr)
return Iter(arr)
arr = Iter([1, 2, 3, 4]).map(lambda a: a + 1).map(lambda a: a * 2)
```
3. On decorators, I decided to add them to my own language as well, because I find them super useful. Want to make a function run in a separate thread? Decorate with `@thread`. Want to silent a function or put it in verbose logging mode? Use `@silent` or `@debug`. It's not honestly difficult to understand them: A decorator takes in a function and outputs another function, that's it. It's syntactic sugar for the following:
```
@decorator
def myFn:
...
```
Instead of doing:
```
fn someFn:
...
myFn = decorator(someFn)
```
What's difficult to understand, and why so much hate on that? The nicest use of decorators I've seen, is with web frameworks like flask. The way routing is done with flask, in my opinion, is much much nicer than how it is done with express (Node.js).
