Outline. 1 Introduction. 2 Meta-Classes in Python. 3 Meta-Classes vs. Traditional OOP. Meta-Classes. Guy Wiener. Introduction. Meta-Classes in Python

Transcription

1 Outline 1 2 3

2 Outline 1 2 3

3 What is Meta-Programming? Definition Meta-Program A program that: One of its inputs is a program (possibly itself) Its output is a program

4 Meta-Programs Nowadays Compilers Code Generators Model-Driven Development Templates Syntactic macros (Lisp-like)

5 The Problem With Static Programming How to share features between classes and class hierarchies? Share static attributes Force classes to adhere to the same protocol Share code between similar methods

6 Definition Meta-Class A class that creates classes Objects that are instances of the same class share the same behavior that are instances of the same meta-class share the same behavior

7 Definition Meta-Class A class that creates classes Objects that are instances of the same class share the same behavior that are instances of the same meta-class share the same behavior create objects Meta-classes create classes

8 Aspect-Oriented Programming () A meta-programming methodology based on Goal: Make all methods that match a pattern adhere to the same behavior (called advice ) Examples Print logging Perform a security check Ask for permission...

9 Aspect-Oriented Programming () A meta-programming methodology based on Goal: Make all methods that match a pattern adhere to the same behavior (called advice ) Examples Print logging Perform a security check Ask for permission... Function decorators are not enough We want to enforce a policy.

10 Example Advice Code if (!connected) connect(); class Client { void send(server) { // send message } void receive(server) { // receive message } }

11 Example Advice Code if (!connected) connect(); class Client { void send(server) { if (!connected) connect(); // send message } void receive(server) { if (!connected) connect(); // receive message } }

12 Programs Components of an meta-program Advices Shared code Patterns Which advice applies to which points in the code (entry or exit of a method)

13 Programs Components of an meta-program Advices Shared code Patterns Which advice applies to which points in the code (entry or exit of a method) Input A program and specifications Output A new program

14 Applying an program on a Program A generic meta-class for Input: class C, advice a, pattern p Output: class C, modified for method m methods(c) do if m matches p then m = apply a on m replace m with m in C end if end for

15 Applying an program on a Program A generic meta-class for Input: class C, advice a, pattern p Output: class C, modified for method m methods(c) do if m matches p then m = apply a on m replace m with m in C end if end for Requires: Reflection Modification

16 Example An aspect for connecting to a server for method m Client do if m has an argument server then insert if (!connected) connect(); before m end if end for

17 The RMI Problem Remove Method Invocation (RMI) A server object is located on one computer Clients invokes methods of the server object from other computers start() stop() Server Object pause(5) Figure: Remote Method Invocation

18 RMI Class Diagram Server start() stop() pause(int) Figure: The original Server class ServerInf start()* stop()* pause(int)* Server+ start()+ stop()+ pause(int)+ Figure: Server class and interface

19 RMI Class Diagram (cont d) ServerInf start()* stop()* pause(int)* Stub+ Skeleton+ ServerImpl+ start()+ stop()+ pause(int)+ over network start()+ stop()+ pause(int)+ start()+ stop()+ pause(int)+ Figure: Server with stub and skeleton

20 RMI ServerInf Generated : start()* stop()* pause(int)* Input: Server interface Output: Skeleton Stub Stub+ Code Generator Skeleton+ start()+ stop()+ pause(int)+ start()+ stop()+ pause(int)+ Figure: generation for RMI

21 Object-Oriented Code Input Class definitions Interfaces, IDL UML Other specifications Output Generated classes Stubs and skeletons Persistent objects Database tables...

22 Object-Oriented Code Input Class definitions Interfaces, IDL UML Other specifications Output Generated classes Stubs and skeletons Persistent objects Database tables... The structure of the program becomes the source for automatically generated code

23 Outline 1 2 3

24 Motivation Problem Python s flexibility makes the code impossible to understand A more organized mechanism is required

25 Motivation Problem Python s flexibility makes the code impossible to understand A more organized mechanism is required The Solution Class are objects Objects are instances of classes

26 Motivation Problem Python s flexibility makes the code impossible to understand A more organized mechanism is required The Solution Class are objects Objects are instances of classes are instances of

27 Extend the type type Responsible for creating new classes The dynamic members of the meta-class become static members of the instance class

28 Creating from Example # Meta-Class class Printable(type): def whoami(self): print "I am ", self. name >>> Foo = Printable( Foo,(),{}) # Empty new class >>> Foo.whoami() I am Foo >>> Foo. class <class Printable > >>> f = Foo() # Object >>> f. class <class Foo >

29 The metaclass field Class C is an instance of a meta-class M if: 1 C has a static field metaclass 2 One of the ancestors classes of C is an instance of M 3 There is a global variable metaclass 4 Otherwise, the default meta-class type is used

30 metaclass Example Declaring a meta-class with metaclass class Bar: metaclass = Printable def foo(self): print foo >>> Bar.whoami() I am a Bar >>> b = Bar() >>> b.foo() foo

31 The Type Constructor The constructor of the type class creates new classes based on the class declaration: type. init (cls, name, bases, dict) cls The class object itself (like self in other methods) name The name of the class bases A list of the base classes dict A dictionary of the methods and static fields of the class

32 What You Can Do With It? The type constructors allow to manipulate the created class: type. init (cls, name, bases, dict) cls Change the content of the class name Change the class name bases Add and remove base classes dict Inspect the content of the class

33 Example: with A logger decorator def log(name, f): def ret(*args): print "enter", name f(*args) print "exit", name return ret

34 with (cont d) A logger meta-class class Logged(type): def init (cls, name, bases, dict): type. init (cls, name, bases, dict) p = re.compile(cls. logmatch ) for attr, item in dict.items(): if callable(item) and p.match(attr): setattr(cls, attr, log(attr, item))

35 Loggin with (cont d) A logged class class Test: metaclass = Logged logmatch =.* def foo(self): print foo >>> t = Test() >>> t.foo() enter foo foo exit foo

36 Automatic Delegate An object of class A that dispatches all message of class B to a target field of type B. Writting a delegate class is a monotonous work But it can be done automatically

37 Using A delegation function decorator def dlgt(cls, method): def ret(self, *args): method(self. tgt, *args) return instancemethod(ret, None, cls) instancemethod takes a function, an object/none and a class and returns a method of the class Auxiliary Print class name def clsname(self): return self. class. name

38 Using (cont d) The Delegate meta-class class Delegate(type): def init (cls, name, bases, dict): type. init (name, bases, dict) tgtclass = cls. tgtclass for name in dir(tgtclass): val = getattr(tgtclass, name) if callable(val): setattr(cls, name, dlgt(cls, val))

39 Using (cont d) The delegated class class A: def bar(self): print clsname(self), bar def baz(self): print clsname(self), baz

40 Using (cont d) The delegating class class B: metaclass = Delegate tgtclass = A def init (self, tgt): self. tgt = tgt def boo(self): print clsname(self), boo

41 Using (cont d) test >>> b = B(A()) >>> b.bar() A bar >>> b.baz() A baz >>> b.boo() B boo

42 Simplified Syntax for with Parameters Thanks to Yoav Goldberg Use a function to create the meta-class def delegate_of(tgtclass): class Delegate(type): def init (cls, name, bases, dict): type. init (name, bases, dict) for name in dir(tgtclass): val = getattr(tgtclass, name) if callable(val): setattr(cls, name, dlgt(cls,val))

43 Simplified Syntax for with Parameters Thanks to Yoav Goldberg Use the function to generate a meta-class class B: metaclass = delegate_of(a) def init (self, tgt): self. tgt = tgt def boo(self): print clsname(self), boo

44 Outline 1 2 3

45 Changes introduces a change to the traditional : Traditional Objects are instances of classes with meta-classes are instances of classes too Figure: Delegate class diagram Figure: Class diagram with meta-classes

46 Pros and Cons Pros Implementing aspects becomes trivial A less vulgar form of code generation New reuse opportunities: Design patterns Static members Class hierarchies... Cool Cons Adds a new level of complexity to Requires hash-based classes Breaks many things: Static types Control flow analysis IDE auto-completion... Difficult to test