Harmony Highlights Proxies & Traits. Tom Van Cutsem Mark S. Miller

Transcription

1 Harmony Highlights Proxies & Traits Tom Van Cutsem Mark S. Miller 1

2 Ecmascript 5 Strict Mode: guards against common pitfalls rejects confusing features (e.g. with statement) throws exceptions instead of failing silently Object-manipulation API javascript.lang.reflect 2

3 Property Descriptors Data and accessor properties Property attributes var point = { x: 5, get y() { return this.x; } }; Object.getOwnPropertyDescriptor(point, x ); { value: 5, writable: true, enumerable: true, configurable: true } Object.getOwnPropertyDescriptor(point, y ); { get: function () { return this.x; }, set: undefined, enumerable: true, configurable: true } 3

4 Property Descriptor Maps var point = { x: 5, get y() { return this.x; } }; Object.defineProperty(point, z, { value: 0, enumerable: true, writable: false, configurable: false }); var point = Object.create( Object.prototype, { x: { value: 5, enumerable: true,... }, y: { get: function() {...}, enumerable: true,... }, z: { value: 0, enumerable: true,... } }); 4

5 Property Descriptor Maps var point = { x: 5, get y() { return this.x; } }; Object.defineProperty(point, z, { value: 0, enumerable: true, writable: false, configurable: false }); name pd x {...} var point = Object.create( Object.prototype, { x: { value: 5, enumerable: true,... }, y: { get: function() {...}, enumerable: true,... }, z: { value: 0, enumerable: true,... } }); y {...} z {...} 4

6 Tamper-proof Objects var point = { x: 5, get y() { return this.x; } }; Object.preventExtensions(point); point.z = 0; // can t add new properties Object.seal(point); delete point.x; // can t delete properties Object.freeze(point); point.x = 7; // can t assign properties 5

7 Proxies 6

8 Dynamic Proxies Generic handling of property access: Generic wrappers: access control, tracing, profiling,... Stratified form of nosuchmethod Generic handling of other operations applicable to objects: Virtual objects: persistent objects, remote objects,... Emulate host objects 7

9 Tracing: static proxies function maketracer(obj) { var proxy = Object.create(Object.getProtoypeOf(obj), {}); } Object.getOwnPropertyNames(obj).forEach(function(name) { var pd = Object.getOwnPropertyDescriptor(obj, name); Object.defineProperty(proxy, name, { get: function() { }); }); trace( get, name, obj); return obj[name]; }, set: function(v) { trace( set, name, obj, v); obj[name] = v; }, // copy attributes from pd return proxy; 8

10 Tracing: static proxies function maketracer(obj) { var proxy = Object.create(Object.getProtoypeOf(obj), {}); } Object.getOwnPropertyNames(obj).forEach(function(name) { var pd = Object.getOwnPropertyDescriptor(obj, name); Object.defineProperty(proxy, name, { get: function() { }); }); trace( get, name, obj); return obj[name]; }, set: function(v) { trace( set, name, obj, v); obj[name] = v; }, // copy attributes from pd return proxy; proxy doesn t reflect structural changes made to obj structural changes made to proxy are not reflected in obj structural changes: added/deleted properties changed property attributes 8

11 Tracing: dynamic proxies function maketracer(obj) { var proxy = Proxy.create({ } get: function(rcvr, name) { trace( get, name, obj); return obj[name]; }, set: function(rcvr, name, val) { trace( set, name, obj, val); },... obj[name] = val; return true; }, Object.getPrototypeOf(obj)); return proxy; 9

12 Tracing: dynamic proxies function maketracer(obj) { var proxy = Proxy.create({ } get: function(rcvr, name) { trace( get, name, obj); return obj[name]; }, set: function(rcvr, name, val) { trace( set, name, obj, val); },... obj[name] = val; return true; }, Object.getPrototypeOf(obj)); return proxy; base proxy handler meta 10

13 Stratified API var proxy = Proxy.create(handler, proto); handler base meta proxy 11

14 Stratified API var proxy = Proxy.create(handler, proto); handler.get(proxy, foo ) handler base proxy.foo meta proxy 11

15 Stratified API var proxy = Proxy.create(handler, proto); handler.get(proxy, foo ) handler.set(proxy, foo, 42) handler base proxy.foo proxy.foo := 42 meta proxy 11

16 Stratified API var proxy = Proxy.create(handler, proto); handler.get(proxy, foo ) handler.set(proxy, foo, 42) handler handler.get(proxy, foo ).apply(proxy,[1,2,3]) base proxy.foo proxy.foo := 42 meta proxy.foo(1,2,3) proxy 11

17 Stratified API var proxy = Proxy.create(handler, proto); handler.get(proxy, foo ) handler.set(proxy, foo, 42) handler handler.get(proxy, foo ).apply(proxy,[1,2,3]) handler.get(proxy, get ) base proxy.foo meta proxy.foo := 42 proxy.foo(1,2,3) proxy.get proxy 11

18 Stratified API var proxy = Proxy.create(handler, proto); handler.get(proxy, foo ) handler.set(proxy, foo, 42) handler handler.get(proxy, foo ).apply(proxy,[1,2,3]) handler.get(proxy, get ) base proxy.foo meta proxy.foo := 42 proxy.foo(1,2,3) proxy.get proxy proto 11

19 Not just property access var proxy = Proxy.create(handler, proto); handler base meta proxy 12

20 Not just property access var proxy = Proxy.create(handler, proto); handler.has( foo ) handler base meta foo in proxy proxy 12

21 Not just property access var proxy = Proxy.create(handler, proto); handler.has( foo ) handler.delete( foo ) handler base meta foo in proxy delete proxy.foo proxy 12

22 Not just property access var proxy = Proxy.create(handler, proto); handler.has( foo ) handler.delete( foo ) var props = handler.enumerate(); for (i=0;i<props.length;i++) { } var prop = props[i];... handler meta base foo in proxy delete proxy.foo proxy for (var prop in proxy) {... } 12

23 Not just property access var proxy = Proxy.create(handler, proto); handler.has( foo ) handler.delete( foo ) var props = handler.enumerate(); for (i=0;i<props.length;i++) { } var prop = props[i];... handler handler.defineproperty( foo, pd) meta base foo in proxy delete proxy.foo proxy for (var prop in proxy) {... } Object.defineProperty(proxy, foo, pd) 12

24 But not quite everything either var proxy = Proxy.create(handler, proto); handler base meta proxy 13

25 But not quite everything either var proxy = Proxy.create(handler, proto); handler base meta proxy === obj proxy 13

26 But not quite everything either var proxy = Proxy.create(handler, proto); handler base meta proxy === obj Object.getPrototypeOf(proxy) => proto proxy proto 13

27 But not quite everything either var proxy = Proxy.create(handler, proto); handler base meta proxy === obj Object.getPrototypeOf(proxy) => proto proxy instanceof Fun proxy proto 13

28 But not quite everything either var proxy = Proxy.create(handler, proto); handler base meta proxy === obj Object.getPrototypeOf(proxy) => proto proxy instanceof Fun typeof proxy => object proxy proto 13

29 Full Handler API handler proxy Object.getOwnPropertyDescriptor(proxy) Object.getPropertyDescriptor(proxy) Object.defineProperty(proxy,name,pd) Object.getOwnPropertyNames(proxy) delete proxy.name for (name in proxy) {... } Object.{freeze seal...}(proxy) name in proxy ({}).hasownproperty.call(proxy, name) receiver.name proxy.name = val Object.keys(proxy) handler.getownpropertydescriptor(name) handler.getpropertydescriptor(name) handler.defineproperty(name, pd) handler.getownpropertynames() handler.delete(name) handler.enumerate() handler.fix() handler.has(name) handler.hasown(name) handler.get(receiver, name) handler.set(proxy, name, val) handler.enumerateown() 14

30 Selective interception base meta object 15

31 Selective interception VM territory (C++) base meta object Javascript territory 15

32 Selective interception VM territory (C++) VM handler base meta object Javascript territory 15

33 Selective interception VM territory (C++) VM handler VM handler base meta host object object Javascript territory 15

34 Selective interception VM territory (C++) VM handler VM handler handler base meta host object object proxy Javascript territory 15

35 Selective interception VM territory (C++) VM handler VM handler handler base meta host object object proxy Javascript territory 15

36 Selective interception VM territory (C++) VM handler VM handler Self-hosted handler base meta host object object proxy Javascript territory 15

37 Selective interception VM territory (C++) VM handler VM handler Self-hosted handler base meta host object object proxy Javascript territory 15

38 Example: no-op forwarding proxy function ForwardingHandler(obj) { this.target = obj; } ForwardingHandler.prototype = { } has: function(name) { return name in this.target; }, get: function(rcvr,name) { return this.target[name]; }, set: function(rcvr,name,val) { this.target[name]=val;return true; }, delete: function(name) { return delete this.target[name]; } enumerate: function() { var props = []; },... proxy for (name in this.target) { props.push(name); }; return props; handler target var proxy = Proxy.create(new ForwardingHandler(o), Object.getPrototypeOf(o)); 16

39 Example: counting property access function makesimpleprofiler(target) { var forwarder = new ForwardingHandler(target); } var count = Object.create(null); forwarder.get = function(rcvr, name) { count[name] = (count[name] 0) + 1; return this.target[name]; }; return { } proxy: Proxy.create(forwarder, Object.getPrototypeOf(target)), get stats() { return count; } 17

40 Example: counting property access function makesimpleprofiler(target) { var forwarder = new ForwardingHandler(target); } var count = Object.create(null); forwarder.get = function(rcvr, name) { count[name] = (count[name] 0) + 1; return this.target[name]; }; return { } proxy: Proxy.create(forwarder, Object.getPrototypeOf(target)), get stats() { return count; } var subject = {... }; var profiler = makesimpleprofiler(subject); runapp(profiler.proxy); display(profiler.stats); 17

41 Function Proxies Javascript functions are objects. Additionally, they are also callable and constructable var call = function() {... }; var construct = function() {... }; var fproxy = Proxy.createFunction(handler, call, construct); handler call construct fproxy 18

42 Function Proxies Javascript functions are objects. Additionally, they are also callable and constructable var call = function() {... }; var construct = function() {... }; var fproxy = Proxy.createFunction(handler, call, construct); call(1,2,3) handler call construct fproxy(1,2,3) fproxy 18

43 Function Proxies Javascript functions are objects. Additionally, they are also callable and constructable var call = function() {... }; var construct = function() {... }; var fproxy = Proxy.createFunction(handler, call, construct); call(1,2,3) construct(1,2,3) handler call construct fproxy(1,2,3) new fproxy(1,2,3) fproxy 18

44 Function Proxies Javascript functions are objects. Additionally, they are also callable and constructable var call = function() {... }; var construct = function() {... }; var fproxy = Proxy.createFunction(handler, call, construct); call(1,2,3) construct(1,2,3) handler.get(fproxy, prototype ) handler call construct fproxy(1,2,3) new fproxy(1,2,3) fproxy.prototype fproxy 18

45 Function Proxies Javascript functions are objects. Additionally, they are also callable and constructable var call = function() {... }; var construct = function() {... }; var fproxy = Proxy.createFunction(handler, call, construct); call(1,2,3) construct(1,2,3) handler.get(fproxy, prototype ) handler call construct fproxy(1,2,3) new fproxy(1,2,3) fproxy.prototype fproxy typeof fproxy => function 18

46 Function Proxies Javascript functions are objects. Additionally, they are also callable and constructable var call = function() {... }; var construct = function() {... }; var fproxy = Proxy.createFunction(handler, call, construct); call(1,2,3) construct(1,2,3) handler.get(fproxy, prototype ) handler call construct fproxy(1,2,3) new fproxy(1,2,3) fproxy.prototype fproxy typeof fproxy => function Object.getPrototypeOf(fproxy) => Function.prototype 18

47 Fixing a Proxy var proxy = Proxy.create(handler, proto); handler base meta proxy 19

48 Fixing a Proxy var proxy = Proxy.create(handler, proto); handler base meta Object.freeze(proxy) Object.seal(proxy) Object.preventExtensions(proxy) proxy 19

49 Fixing a Proxy var proxy = Proxy.create(handler, proto); var pdmap = handler.fix(); if (pdmap === undefined) throw TypeError(); become(proxy, Object.freeze( Object.create(proto, pdmap))); handler meta base Object.freeze(proxy) Object.seal(proxy) Object.preventExtensions(proxy) proxy 19

50 Fixing a Proxy var proxy = Proxy.create(handler, proto); var pdmap = handler.fix(); if (pdmap === undefined) throw TypeError(); become(proxy, Object.freeze( Object.create(proto, pdmap))); handler meta base Object.freeze(proxy) Object.seal(proxy) Object.preventExtensions(proxy) proxy Trapping fix Fixed 19

51 Fixing a Proxy var proxy = Proxy.create(handler, proto); var pdmap = handler.fix(); if (pdmap === undefined) throw TypeError(); become(proxy, Object.freeze( Object.create(proto, pdmap))); meta base Object.freeze(proxy) Object.seal(proxy) Object.preventExtensions(proxy) proxy Trapping fix Fixed 19

52 Status Presented at ECMA TC-39 meetings Proposal for ES-Harmony tinyurl.com/harmony-proxies Andreas Gal (Mozilla) implemented a prototype as an extension of Tracemonkey 20

53 Micro-benchmark 21

54 Proxies: summary Dynamic proxies enable: Generic wrappers: access control, profiling, adaptors,... Virtual objects: persistent objects, remote objects, emulated host objects,... API: Robust (stratified, not all operations intercepted) Secure (can t trap non-proxy or fixed objects) Performance: no overhead for non-proxy objects 22

55 Traits 23

56 Traits in a nutshell An alternative to mixins & multiple inheritance A trait provides and requires a set of methods Robust composition: Name clashes lead to conflicts that must be resolved Trait composition is commutative & associative: composition order is irrelevant First in Squeak Smalltalk (~2003), adoption in Perl 6, PLT Scheme, Fortress,... 24

57 traits.js library Motivation: More robust than existing prototypical inheritance & mixin patterns Easier creation of tamper-proof objects Based on ES5 property descriptor API Backwards-compatible with ES3 Works in browser and stand-alone 25

58 Minimal core API <script src= traits.js ></script> Trait construction var t = Trait({ a: Trait.required, b: function(){ return this.a + 1; } }) Trait composition var tc = Trait.compose(t1, t2,...) Trait resolution var tr = Trait.resolve({ a: c, b: undefined }, t) Trait instantiation var o = Trait.create(proto, t) 26

59 Enumerable trait var EnumerableTrait = Trait({ foreach: Trait.required, } }); map: function(fun) { var seq = []; this.foreach(function(e) { seq.push(fun(e)); }); return seq; }, filter: function(pred) { var seq = []; this.foreach(function(e) { if (pred(e,i)) { seq.push(e); } }); return seq; }, reduce: function(init, fun) { var result = init; this.foreach(function(e) { result = fun(result, e); }); return result; 27

60 Enumerable interval function makeinterval(min, max) { return Trait.create(Object.prototype, } Trait.compose( EnumerableTrait, Trait({ start: min, end: max, contains: function(e) { return (min <= e) && (e < max); }, foreach: function(consumer) { for (var i = min; i < max; i++) { consumer(i); } } }))); var int = makeinterval(0,5); int.reduce(0, function(a,b){return a+b;}); // 10 28

61 Trait construction Trait({ a: Trait.required, }); b: function() {...}, c: 42, get d() {...} Traits are property descriptor maps { a: { value: undefined, } required: true, enumerable: false }, b: { value: function() {...}, method: true, enumerable: true }, c: { value: 42, enumerable: true }, d: { get: function(){...}, } enumerable: true 29

62 Trait composition: conflicts T2 a b <methodp> <methodp> T1 a b c <requiredp> <methodp> <datap> Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 30

63 Trait composition: conflicts T2 a b <methodp> <methodp> Trait.compose(T1,T2) Tc a <methodp> T1 b c <conflictp> <datap> a <requiredp> b <methodp> c <datap> Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 30

64 Trait composition: conflicts T2 a b <methodp> <methodp> Trait.compose(T1,T2) Tc a <methodp> T1 b c <conflictp> <datap> a b <requiredp> <methodp> Trait.create(proto, Tc) c <datap> Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 30

65 Trait resolution T2 a b <methodp> <methodp> T1 a b c <requiredp> <methodp> <datap> Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 31

66 Trait resolution T2 Trait.resolve( {b:undefined}, T2); Tr a <methodp> a <methodp> b <methodp> b <requiredp> T1 a b c <requiredp> <methodp> <datap> Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 31

67 Trait resolution T2 Trait.resolve( {b:undefined}, T2); Tr a b <methodp> <methodp> a b <methodp> <requiredp> Tc T1 Trait.compose(T1,Tr) a b c <methodp> <methodp> <datap> a <requiredp> b <methodp> c <datap> Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 31

68 Trait resolution T2 Trait.resolve( {b:undefined}, T2); Tr a b <methodp> <methodp> a b <methodp> <requiredp> Tc T1 Trait.compose(T1,Tr) a b c <methodp> <methodp> <datap> a b c <requiredp> <methodp> <datap> Trait.create( proto, Tc) Trait({ a: Trait.required, }) b: function() {...this.a... }, c: 42 a function(){...} b function(){...} c 42 31

69 Trait instantiation Trait.create(proto, { a: { }) value: function() {... this.b... }, method: true }, b: { } value: 42 Trait instances are tamper-proof Object.create(proto, { a: { } }) }, }, value: function() {... this.b... b: { value: 42 + throws on conflict/required + binds this of methods + freezes object and methods 32

70 Traits: summary traits.js: a minimal trait composition library Traits as property descriptor maps: Object.create generates flexible objects Trait.create generates tamper-proof objects Open issue: sharing bound methods between trait instances 33

71 Conclusion ES5-strict is a robust programming language Proxies: robust metaprogramming API for ES-harmony Traits: robust composition API for ES5 Next: abstractions for robust event-driven programming es-lab.googlecode.com 34