Programming Languages

Transcription

1 TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Programming Languages Mixins Dr. Michael Petter Winter 2014 Mixins 1 / 30

2 What advanced techiques are there besides multiple implementation inheritance? Mixins Introduction 2 / 30

3 Outline Weak implementation inheritance 1 Decorator Problem 2 Wrapper Problem Inheritance in Detail 1 Models for single inheritance 2 Introducing Mixins 3 Modelling Mixins Mixins in the wild 1 Mixins as C++-Pattern 2 Native Mixins Mixins Introduction 3 / 30

4 The Adventure Game Door ShortDoor canpass(person p)? ShortLockedDoor canopen(person p) canpass(person p) LockedDoor canopen(person p) Mixins Introduction The Adventure Game 4 / 30

5 The Adventure Game <interface>doorlike canpass(person p) canopen(person p) Door Short canpass(person p) Locked canopen(person p) ShortLockedDoor canopen(person p) canpass(person p)! Door implements empty methods! Doorlike must anticipate wrappers Mixins Introduction The Adventure Game 5 / 30

6 The Wrapper FileStream read() write() SocketStream read() write()? SynchRW acquirelock() releaselock()! Cannot inherit from both seperately! Creating new wrapping Classes duplicates code Mixins Introduction The Wrapper 6 / 30

7 The Wrapper FileStream read() write() Stream read() write() SocketStream read() write() SynchRW read() write() acquirelock() releaselock()! Undoes specialization! Needs common ancestor Mixins Introduction The Wrapper 7 / 30

8 Let s go back to the basics of inheritance Mixins Mixins Modelling Inheritance 8 / 30

9 Classes and Methods The building blocks for classes are a countable set of method names N a countable set of method bodies B Classes map names to elements from the flat lattice B (called bindings), consisting of: method bodies B or classes C attribute offsets N + (yet) undefined in conflict and the partial order m for each m B Definition (Abstract Class C) A partial function c : N B is called abstract class. Definition (Interface and Class) An abstract class c is called interface iff n pre(c). c(n) =. (concrete) class iff n pre(c). c(n). (with pre beeing the preimage) Mixins Mixins Modelling Inheritance 9 / 30

10 Computing with Classes and Methods Definition (Family of classes C) We call the set of all maps from names to bindings the family of abstract classes C := N B. Several possibilites for composing maps C C: the symmetric join, defined componentwise: b 2 if b 1 = or n / pre(c 1 ) b 1 if b 2 = or n / pre(c 2 ) (c 1 c 2 )(n) = b 1 b 2 = b 2 if b 1 = b 2 otherwise where b i = c i (n) in contrast, the asymmetric join, defined componentwise: { c 1 (n) if n pre(c 1 ) (c 1 c 2 )(n) = c 2 (n) otherwise Mixins Mixins Modelling Inheritance 10 / 30

11 Example: Smalltalk-Inheritance Smalltalk inheritance is the archetype for inheritance in mainstream languages like Java or C# inheriting smalltalk-style establishes a reference to the parent Definition (Smalltalk inheritance ( )) Smalltalk inheritance is the binary operator : C C C, definied by c 1 c 2 = {super c 2 } (c 1 c 2 ) Example: Doors Door = {canp ass, canopen } LockedDoor = {canopen 0x } Door = {super Door} ({canopen 0x } Door) = {super Door, canopen 0x , canp ass } Mixins Mixins Modelling Inheritance 11 / 30

12 Excursion: Beta-Inheritance In Beta-style inheritance the design goal is to provide security from replacement of a method by a different method. methods in parents dominate methods in subclass the keyword inner explicitely delegates control to the subclass Definition (Beta inheritance ( )) Beta inheritance is the binary operator : C C C, definied by c 1 c 2 = {inner c 1 } (c 2 c 1 ) Example (equivalent syntax): class Person { String name ="Axel Simon"; public String tostring(){ return name+inner.tostring();}; }; class Graduate exts Person { public extension String tostring(){ return ", Ph.D."; }; }; Mixins Mixins Modelling Inheritance 12 / 30

13 Extension: Attributes Remark: Modelling attributes is not in our main focus. Anyway, most mainstream languages nowadays are designed so that attributes are not overwritten: Definition (Mainstream inheritance ( )) The exted mainstream inheritance : C C C binds attributes statically: c 2 if n = super (c 1 if n pre(c 1 ) c 2 (n) N + c 2 )(n) = c 1 (n) if n pre(c 1 ) c 2 (n) otherwise Mixins Mixins Modelling Inheritance 13 / 30

14 So what do we really want? Mixins Mixins Introducing Mixins 14 / 30

15 Adventure Game with Code Duplication Door ShortDoor canpass(person p) LockedDoor canopen(person p) ShortLockedDoor canopen(person p) canpass(person p) Mixins Mixins Introducing Mixins 15 / 30

16 Adventure Game with Mixins <mixin>locked canopen(person p) Door canopen(person p) canpass(person p) <mixin>short canpass(person p) mixin compose <mixin>shortlocked Mixins Mixins Introducing Mixins 16 / 30

17 Adventure Game with Mixins class Door { boolean canopen(person p) { return true; }; boolean canpass(person p) { return p.size() < 210; }; } mixin Locked { boolean canopen(person p){ if (!p.hasitem(key)) return false; else return super.canopen(p); } } mixin Short { boolean canpass(person p){ if (p.height()>1) return false; else return super.canpass(p); } } class ShortDoor = Short(Door); class LockedDoor = Locked(Door); mixin ShortLocked = Short o Locked; class ShortLockedDoor = Short(Locked(Door)); class ShortLockedDoor2 = ShortLocked(Door); Mixins Mixins Introducing Mixins 17 / 30

18 Back to the blackboard! Mixins Mixins Modelling Mixins 18 / 30

19 Abstract model for Mixins A Mixin is a unary second order type expression. In principle it is a curried version of the Smalltalk-style inheritance operator. In certain languages, programmers can create such mixin operators: Definition (Mixin) The mixin constructor mixin : C (C C) is a unary class function, creating a unary class operator, defined by: mixin(c) = λx. c x! Note: Mixins can also be composed : Example: Doors Locked = {canopen 0x1234} Short = {canp ass 0x4711} Composed = mixin(short) (mixin(locked)) = λx. Short (Locked x) = λx. {super Locked} ({canopen 0x1234, canp ass 0x4711} x) Mixins Mixins Modelling Mixins 19 / 30

20 Wrapper with Mixins FileStream read() write() SocketStream read() write() <mixin>synchrw acquirelock() releaselock() mixin mixin SynchedFileStream read() write() SynchedSocketStream read() write() Mixins Mixins Modelling Mixins 20 / 30

21 Mixins on Implementation Level class Door { boolean canopen(person p)... boolean canpass(person p)... } mixin Locked { boolean canopen(person p)... } mixin Short { boolean canpass(person p)... } class ShortDoor = Short(Door); class ShortLockedDoor = Short(Locked(Door));... ShortDoor d = new ShortLockedDoor();... Short canpass() Locked super canopen() super Door...! non-static super-references dynamic dispatching without precomputed virtual table Mixins Mixins Modelling Mixins 21 / 30

22 Surely multiple inheritance is powerful enough to simulate mixins? Mixins Mixins Simulating Mixins in C++ 22 / 30

23 Simulating Mixins in C++ template <class Super> class SyncRW : public Super { public: virtual int read(){ acquirelock(); int result = Super::read(); releaselock(); return result; }; virtual void write(int n){ acquirelock(); Super::write(n); releaselock(); }; //... acquirelock & releaselock }; Mixins Mixins Simulating Mixins in C++ 23 / 30

24 Simulating Mixins in C++ template <class Super> class LogOpenClose : public Super { public: virtual void open(){ Super::open(); log("opened"); }; virtual void close(){ Super::close(); log("closed"); }; protected: virtual void log(char*s) {... }; }; class MyDocument : public SyncRW<LogOpenClose<Document>> {}; Mixins Mixins Simulating Mixins in C++ 24 / 30

25 True Mixins vs. C++ Mixins True Mixins super natively supported Mixins as Template do not offer composite mixins C++ Type system not modular Mixins have to stay source code Hassle-free simplified version of multiple inheritance C++ Mixins Mixins reduced to templated superclasses Can be seen as coding pattern Common properties of Mixins Linearization is necessary Exact sequence of Mixins is relevant Mixins Mixins Simulating Mixins in C++ 25 / 30

26 Ok, ok, show me a language with native mixins! Mixins Mixins Native Mixins in Python 26 / 30

27 Ruby class Person attr_accessor :size def = 160 def haskey true class Door def canopen (p) true def canpass(person) person.size < 210 module Short def canpass(p) p.size < 160 and super(p) module Locked def canopen(p) p.haskey() and super(p) class ShortLockedDoor < Door include Short include Locked p = Person.new d = ShortLockedDoor.new puts d.canpass(p) Mixins Mixins Native Mixins in Python 27 / 30

28 Ruby class Door def canopen (p) true def canpass(person) person.size < 210 module Short def canpass(p) p.size < 160 and super(p) module Locked def canopen(p) p.haskey() and super(p) module ShortLocked include Short include Locked class Person attr_accessor :size def = 160 def haskey true p = Person.new d = Door.new d.ext ShortLocked puts d.canpass(p) Mixins Mixins Native Mixins in Python 28 / 30

29 Lessons Learned Lessons Learned 1 Formalisms to model inheritance 2 Mixins provide soft multiple inheritance 3 Multiple inheritance can not compensate the lack of super reference 4 Full extent of mixins only when mixins are 1st class language citizens Mixins Mixins Native Mixins in Python 29 / 30

30 Further reading... Gilad Bracha and William Cook. Mixin-based inheritance. European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (OOPSLA/ECOOP), James Britt. Ruby core reference, December URL Matthew Flatt, Shriram Krishnamurthi, and Matthias Felleisen. Classes and mixins. Principles of Programming Languages (POPL), Mixins Further materials 30 / 30