MetaProgramming. Programming from above. Python. C++ (Template MetaProgramming TMP)

Transcription

1 MetaProgramming Programming from above Python C++ (Template MetaProgramming TMP)

2 Python (based on David Debugging with Print A function def add(x, y): return x + y A function with debugging def add(x, y): print('add') return x + y

3 Many Functions w/ Debug def add(x, y): print('add') return x + y def sub(x, y): print('sub') return x y def mul(x, y): print('mul') return x * y def div(x, y): print('div') return x / y

4 Many Functions w/ Debug def add(x, y): print('add') return x + y def sub(x, y): print('sub') return x y DRY Don t Repeat Yourself def mul(x, y): print('mul') return x * y def div(x, y): print('div') return x / y

5 Decorators A decorator is a function that creates a wrapper around another function The wrapper is a new function that works exactly like the original function (same arguments, same return value) except that some kind of extra processing is carried out

6 *args and **kwargs def func(*args, **kwargs): # args is tuple of position args # kwargs is dict of keyword args... func(1, 2, x=3, y=4, z=5) args = (1, 2) kwargs = { 'x': 3, 'y': 4, 'z': 5 }

7 *args and **kwargs args = (1, 2) kwargs = { 'x': 3, 'y': 4, 'z': 5 } func(*args, **kwargs) Same as func(1, 2, x=3, y=4, z=5)

8 A Debugging Decorator from functools import wraps def debug(func): msg = func. def wrapper(*args, **kwargs): print(msg) return func(*args, **kwargs) return wrapper Application (wrapping) func = debug(func)

9 A Debugging Decorator from functools import wraps def debug(func): msg = func. def wrapper(*args, **kwargs): print(msg) return func(*args, **kwargs) return copies metadata Name and doc string Function attributes

10 Decorator Syntax The definition of a function and wrapping almost always occur together def add(x,y): return x+y add = syntax performs the same def add(x,y): return x+y

11 Example def add(x,y): return def sub(x,y): return x-y No implementation def mul(x,y): return def div(x,y): return x/y

12 The Big Picture Debugging code is isolated to single location This makes it easy to change (or to disable) User of a decorator doesn't worry about it

13 Variation: Logging from functools import wraps import logging def debug(func): log = logging.getlogger(func. module ) msg = func. def wrapper(*args, **kwargs): log.debug(msg) return func(*args, **kwargs) return wrapper

14 Variation: Optional Disable from functools import wraps import logging def debug(func): if 'DEBUG' not in os.environ: return func log = logging.getlogger(func. module ) msg = func. def wrapper(*args, **kwargs): log.debug(msg) return func(*args, **kwargs) return wrapper Key idea: Can change decorator independently of code that uses it

15 C++ MetaProgramming C++ does not directly provide facilities for metaprogramming The template machinary was discovered to support it It uses two key features of templates, not commonly available in generic programming Constant parameters Specialization In fact, C++ s template machinary is Turing complete Ideas taken from Todd Veldhuizen, Andrei Alexandrescu and Boost Library

16 Factorial - The Simplest Example template<int N> class Factorial { public: enum { value = N * Factorial<N-1>::value }; }; template<> class Factorial<0> { public: enum { value = 1 }; }; Usage: int n = Factorial<10>::value;

17 Conditional template<bool C> struct IF { static inline void exe() { f(); } // true case }; template<> struct IF<false> { static inline void exe() { g(); } // false case }; f() andg() may be template parameters Usage: IF<condition>::exe();

18 Larger Type // choose the larger of two types template<typename T1, typename T2, bool choose1 = (sizeof(t1) > sizeof(t2))> struct choose_larger { typedef T1 type; }; // specialization for sizeof(t2) >= sizeof(t1) template< typename T1, typename T2 > struct choose_larger< T1, T2, false > { typedef T2 type; }; Usage: typedef T; typedef S; choose_larger<t,s>::type some_var;

19 Loops template<void f(int), int I> class Loop { public: static inline void exe() { f(i); Loop<f, I-1>::exe(); } }; // Specialization provides base case for recursion template<void f(int)> class Loop<f, 0> { public: static inline void exe() { f(0); } }; Usage: Loop<g, N>::exe();

20 Lists template< typename First, typename Rest > struct cons { typedef First first; typedef Rest rest; }; Usage: struct nil {}; typedef cons<int, cons<long, cons<std::vector<double>, nil> > > my_types;

21 Largest in a List (using Larger Type) // get the largest of a cons-list template< typename T > struct largest; // specialization to peel apart the cons list template< typename First, typename Rest > struct largest< cons<first,rest> > : choose_larger<first, typename largest<rest>::type> { }; // type inherited from base // specialization for loop termination template<typename First> struct largest< cons<first,nil> > { typedef First type; }; Usage: largest<my_types>::type a_var;

22 בהצלחה מכל הבחינות בכל הבחינות