prototype __proto__ super and delegation

[cbare]

Hello JS Gurus,

One thing I haven't figured out about javascript is the treatment of
__proto__.

Inheritence, whether prototypes or class-based, is just a shorthand
form of delegation (leaving aside dynamic dispatch).

In Java a derived class serves as a wrapper for its superclass. The
derived class can easily access members of its super class using the
nice "super" keyword. Why, in javascript, is this functionality buried
in the unofficial "__proto__" property? It seems that it must have
been the intent of the language designer that explicitly accessing the
prototype chain is a bad thing for some reason, although I can't see
any reason.

By googling, you can find a lot of weird hacks to add "super"-like
functionality to javascript, although many of them look misguided to
me. It certainly seems that this is a commonly confusing part of the
language.

If __proto__ were an official part of the language, implementing a
decorator or proxy pattern would be nicely simplified compared to
class-based inheritence. The "before-and-after" style of AOP (which is
just another style of shorthand for delegation) would be possible
without any crazy tricks.

So, anyone care to set me straight? Why isn't __proto__ or something
like it a well defined part of javascript? Shouldn't it be??

Thanks,

-chris

[Peter Michaux]

On Oct 29, 4:05 pm, Thomas 'PointedEars' Lahn <[e-mail]>
wrote:

cbare wrote:

If __proto__ were an official part of the language, implementing a
decorator or proxy pattern would be nicely simplified compared to
class-based inheritence. The "before-and-after" style of AOP (which is

What do you mean by AOP?

Aspect-oriented programming. It's what's cool these days. It the
extreme opposite of having single DOM0 event handler. It is all about
decoupling concerns.

just another style of shorthand for delegation) would be possible
without any crazy tricks.

So, anyone care to set me straight? Why isn't __proto__ or something
like it a well defined part of javascript?

It should be part of the language. The Self language has an
interesting way of assigning multiple parent objects (aka prototypes.)
If this was possible in JavaScript it might be a nice way to have
multiple inheritance. Certainly in a prototype-based language I would
imagine that there would be more standard language-level support for
manipulating the prototype(s) of an object.

It is a well-defined part of JavaScript. It is an implementation-dependent
extension of ECMAScript, though. But that is so for several JavaScript
features, especially lately.

Shouldn't it be??

I think so.

Why, `.__proto__' is but a JavaScript shortcut for the ECMAScript-defined
`.constructor.prototype'.

obj.__proto__ is not a short cut for obj.constructor.prototype. For
example...


var adam = {
name: 'Adam',
speak: function() {alert('get away from that snake');}
};

var eve = {
name: 'Eve',
speak: function() {alert('that apple sure looks juice');}
};

function Person(name) {
this.name = name;
}
Person.prototype = adam;
// repair
Person.prototype.constructor = Person;

var cain = new Person('Cain');
cain.speak(); // like adam
// sex change
cain.__proto__ = eve;
cain.speak(); // NOW like eve

var able = new Person('Able');
able.speak(); // like adam
//(Cain's sex change had no affect
// on people created in the future)
able.constructor.prototype = eve;
able.speak(); // STILL like adam

var mary = new Person('Mary');
mary.speak(); // like eve
Peter

[Thomas 'PointedEars' Lahn]

Peter Michaux wrote:

On Oct 29, 4:05 pm, Thomas 'PointedEars' Lahn <[e-mail]>
wrote:

>cbare wrote:

>>If __proto__ were an official part of the language, implementing a
decorator or proxy pattern would be nicely simplified compared to
class-based inheritence. The "before-and-after" style of AOP (which is

What do you mean by AOP?

Aspect-oriented programming. It's what's cool these days.

That must be it. I have never had much interest in hypes.

It the extreme opposite of having single DOM0 event handler.

And what would a "DOM0 event handler" be?

It is all about decoupling concerns.

So AOP is nothing more than a synonym for the misguided "Unobtrusive
JavaScript" hype?

>Why, `.__proto__' is but a JavaScript shortcut for the ECMAScript-defined
`.constructor.prototype'.

obj.__proto__ is not a short cut for obj.constructor.prototype.

I think it is if you set up the prototype chain properly. I will look into
this later.
PointedEars

[Peter Michaux]

On Oct 30, 2:52 am, Thomas 'PointedEars' Lahn <[e-mail]>
wrote:

Peter Michaux wrote:

On Oct 29, 4:05 pm, Thomas 'PointedEars' Lahn <[e-mail]>
wrote:

cbare wrote:
If __proto__ were an official part of the language, implementing a
decorator or proxy pattern would be nicely simplified compared to
class-based inheritence. The "before-and-after" style of AOP (which is
What do you mean by AOP?

Aspect-oriented programming. It's what's cool these days.

That must be it. I have never had much interest in hypes.

Ignore the hype. APO is useful.

It the extreme opposite of having single DOM0 event handler.

And what would a "DOM0 event handler" be?

<body onload="alert('an explicit example of DOM0 event handler');">

It is all about decoupling concerns.

So AOP is nothing more than a synonym for the misguided "Unobtrusive
JavaScript" hype?

No. Nothing to do with JavaScript.

http://en.wikipedia.org/wiki/Aspect-...ed_programming

Why, `.__proto__' is but a JavaScript shortcut for the ECMAScript-defined
`.constructor.prototype'.

obj.__proto__ is not a short cut for obj.constructor.prototype.

I think it is if you set up the prototype chain properly. I will look into
this later.

One has to do with constructing new objects. The other with already-
constructed objects.

Peter

[Thomas 'PointedEars' Lahn]

Peter Michaux wrote:

[...] Thomas 'PointedEars' Lahn [...] wrote:

>Peter Michaux wrote:

>>On Oct 29, 4:05 pm, Thomas 'PointedEars' Lahn <[e-mail]>
wrote:
cbare wrote:
If __proto__ were an official part of the language, implementing a
decorator or proxy pattern would be nicely simplified compared to
class-based inheritence. The "before-and-after" style of AOP (which is
What do you mean by AOP?
Aspect-oriented programming. It's what's cool these days.

That must be it. I have never had much interest in hypes.

Ignore the hype. APO is useful.

That remains to be seen.

>>It the extreme opposite of having single DOM0 event handler.

And what would a "DOM0 event handler" be?

<body onload="alert('an explicit example of DOM0 event handler');">

This is not at all a "DOM0 event handler". It is a standardized attribute
(of HTML 4.01) that provides listener code for the equally standardized
`load' event (of DOM Level 2 Events).

>>It is all about decoupling concerns.

So AOP is nothing more than a synonym for the misguided "Unobtrusive
JavaScript" hype?

No. Nothing to do with JavaScript.

http://en.wikipedia.org/wiki/Aspect-...ed_programming

Thanks for the pointer; I would probably have found that shortly after, though.

>>>Why, `.__proto__' is but a JavaScript shortcut for the ECMAScript-defined
`.constructor.prototype'.
obj.__proto__ is not a short cut for obj.constructor.prototype.

I think it is if you set up the prototype chain properly. I will look into
this later.

One has to do with constructing new objects. The other with already-
constructed objects.

Your statement does not make sense.
PointedEars
--
"Use any version of Microsoft Frontpage to create your site. (This won't
prevent people from viewing your source, but no one will want to steal it.)"
-- from <http://www.vortex-webdesign.com/help/hidesource.htm>

[John G Harris]

On Mon, 29 Oct 2007 at 22:45:18, in comp.lang.javascript, cbare wrote:

<snip>

>So, anyone care to set me straight? Why isn't __proto__ or something
like it a well defined part of javascript? Shouldn't it be??

A 'super' facility needs read access to the prototype chain. You already
have that with a little extra code in the constructor.

Remember, javascript expects programmers to do more of the work
themselves than do other (compiled) languages.

John
--
John Harris

[John G Harris]

On Tue, 30 Oct 2007 at 04:25:52, in comp.lang.javascript, Peter Michaux
wrote:

<snip>

>// sex change
cain.__proto__ = eve;
cain.speak(); // NOW like eve

<snip>

How do you arrange that an assignment to cain.__proto__ cuts cain's
salary now that he is a she ?

Rather than change the cain object's type you should create a new cain
belonging to the other type and use that from now on.

John
--
John Harris