function-attributes

I want different functions to be executable only if the logged in user has the required permission level. To make my life more complexly simply I want to use decorators. Below I attempy to set attribute permission on 'decorated' functions - as shown below. def permission(permission_required): def wrapper(func): def inner(*args, **kwargs): setattr(func, 'permission_required', permission_required) return func(*args, **kwargs) return inner return wrapper @permission('user') def do_x(arg1, arg2): ... @permission('admin') def do_y(arg1, arg2): ... But when I do: fn = do_x if logged_in_user.access

I have a C++ class that is the frontend for a logging system. Its logging function is implemented using C++11's variadic templates: template <typename... Args> void Frontend::log(const char *fmt, Args&&... args) { backend->true_log(fmt, std::forward<Args>(args)...); } Each logging backend implements its own version of true_log , that, among other things, uses the forwarded parameters to call vsnprintf . E.g.: void Backend::true_log(const char *fmt, ...) { // other stuff.. va_list ap; va_start(ap, fmt); vsnprintf(buffer, buffer_length, fmt, ap); va_end(ap); // other stuff.. } Everything works

pure is a function attribute which says that a function does not modify any global memory. const is a function attribute which says that a function does not read/modify any global memory. Given that information, the compiler can do some additional optimisations. Example for GCC: float sigmoid(float x) __attribute__ ((const)); float calculate(float x, unsigned int C) { float sum = 0; for(unsigned int i = 0; i < C; ++i) sum += sigmoid(x); return sum; } float sigmoid(float x) { return 1.0f / (1.0f - exp(-x)); } In that example, the compiler could optimise the function calculate to: float