At present, multi-argument function decorators are a little bit tricky to implement. As an example (somewhat contrived), suppose that `wait` is a function decorator which haults program execution for a few seconds before calling the wrapped function. If you do not pass a float value into *delay* then the default value is 1 second. #EXAMPLE 1A @wait def print_something(something): print (something) #EXAMPLE 2A @wait(0.2) def print_something_else(something): print (something) The `@wait` gets implemented almost like the following code: # EXAMPLE 1B def print_something(something): print (something) print_something = wait(print_something) # EXAMPLE 2B temp = wait(0.2) def print_something_else(something): print (something) print_something = temp(print_something) What is tricky is the following: * if `Wait` has no arguments: `Wait` is the decorator. else: # `Wait` receives arguments `Wait` is not the decorator itself. Instead, `Wait` ***returns*** the decorator* As a result, people write strange-looking (hard-to-read) decorators, like the following: def wait(func=None, delay=1.0): def decorator_wait(func): def wrapper_wait(*args, **kwargs): time.sleep(delay) return func(*args, **kwargs) return wrapper_wait return decorator_wait(func) if func is not None else decorator_wait This suggestion is that a new operator be introduced. The old @-syntax for decorators would remain unchanged, preserving backwards compatibility. It does not really matter to me what string is used for the operator, but I was thinking *$*, or if not that !@ with an interobang before the @. Our opening example of how it would work is shown below: # Example 3A $dec(1, 2, 3) def foo(): pass ########################################### # Example 3B def foo(): pass foo = dec(foo, 1, 2, 3) Examples 3A and 3B are meant to be equivalent. The new decorator operator would simply pass the decorated function into the decorator as the leftmost argument. @wait def slowly_print_something(something): print(something) #-------------------------------- def slowly_print_something(something): print(something) slowly_print_something = wait(slowly_print_something) ################################################## @wait(3.0) def slowly_print_something_else(something_else): print(something_else) #----------------------------------- def bar(something_else): print(something_else) slowly_print_something_else = wait(bar, 3.0) ###################################################### import time def wait(inny, delay=1.0): def outty(*args, **kwargs): time.sleep(delay) return inny(*args, **kwargs) return outty Maybe call them "dollar decorators," or if the !@ syntax is used, then maybe call them "bang decorators." I care more about the functionality than the exact strings of symbol which is used to signal the interpreter what's coming next.