[PATCH] [TEST] Constructor wrapper should return value

+1 but it'd better be tested! :)

I second this. Just the other day I was wondering why there was no return functionality.

Can you a patch for the base.html unit test as well. To confirm nothing goes wrong (I really don't think anything should)

For what it is worth, +1.

But be aware that the you can not return scalars (boolean, int, string), only objects, things that can be created with new.

Removed debugging code from test.

Here's a simpler test (can't make a proper diff at the moment)

var Dummy = Class.create({
  initialize: function() {
    return {foo: 'bar'};
  }
})

var dummy = new Dummy();
this.assertIdentical('bar', dummy.foo);

After some discussions I don't believe this will ever make it into the core.

Why?

Replying to jdalton:

After some discussions I don't believe this will ever make it into the core.

Why?

var Dummy = Class.create({
  initialize: function() {
    return {foo: 'bar'};
  },
  method: function(){
    return 'method';
  }
})

var dummy = new Dummy();

dummy.foo; // => 'bar'
dummy.method; // => undefined
dummy instanceof Dummy; // => false

dumy isnt instanceof Dummy

Your observations are accurate but don't answer the question of "Why".

1. The JavaScript standard allows returning alternative objects from constructors.
2. The JavaScript standard has the exact same restrictions you have noted.

So why has Prototype added this restriction?

I don't mean to be snotty, but observing that core JS itself is less than "regular" with this feature doesn't really answer the question of why Prototype has removed it. Is it Prototype policy to suppress functionality in core JS that is "irregular"?

You are free to mofiy your version of Prototype. Sam does not like the idea of dummy not an instance of dummy.

For the record I personally don't see the harm in allowing users to return values from the constructor. I will reopen ticket in hopes of future discussion.

Thanks. FWIW, I did got a lot of traction in the #prototype forum when I first mentioned this patch. Far from being turned off by the irregularity of non-traditional returns from constructors, many wanted to be able to return 'false'. They lost interest when the learned that JS requires that the return be a descendant of Object (no primitive types allowed).

The biggest opportunity opened up by this patch is the return of cached values. If I have

var ExpensiveToFetchServerClass = Class.create({
  initialize: function(id) {
    var cached_value = ExpensiveToFetchServerClass.cache.get(id);
    return cached_value if cached_value;
    ...
    ExpensiveToFetchServerClass.cache.set(id, this);
  }
})

var x = new ExpensiveToFetchServerClass(25);  // Expensive fetch
...
var y = new ExpensiveToFetchServerClass(25);  // Return from cache.

And another more abstract but complete example:

var Factorial(n) = Class.create({
  initialize: function(n) {
    var cached_value = Factorial.cache.get(n);
    return cached_value if cached_value;
    var value = n * Factorial(n-1)
    Factorial.cache.set(n, value);
    return value;
  }
})

Anyway, thanks for keeping the door open.

-Chris