Question

implement change prototype, so why not just directory change it with ‘some class’.prototype…, It seems very useless or palaver

Answer 1

There are two aspects to implement. In a Class context and on Objects (Types/Natives).

Common benefits

Common between them is, they are API. Because it’s API, MooTools can add ways that ensure that you don’t (accidentally) overwrite prototype methods that are protected on various Native types. See this bit which forces protection for many native methods: https://github.com/mootools/mootools-core/blob/master/Source/Core/Core.js#L238-282

Also, implement is overloaded – which means you can pass on an object that implements more than one method at the same time, rather than break and have a new line for each prototype call.

Function Methods in Classes are wrapped.

These decorators are available:

Function.implement({

    hide: function(){
        this.$hidden = true;
        return this;
    },

    protect: function(){
        this.$protected = true;
        return this;
    }

});

This means you can do

Obj.implement({
   foo: foo.hide(),
   bar: bar.protect()
});

This allows you to have non-wrapped methods via .hide() to add properties that are not wrapped:

Number.prototype.$family = function(){
    return isFinite(this) ? 'number' : 'null';
}.hide();

.protect() is used by Class, see below.

This does not mean you can’t do Number.prototype.$family = somethingElse – you can.

Specifics to Class

When using implement on a class constructor, notice reference to $hidden and call to wrap():

var implement = function(key, value, retain){
    if (Class.Mutators.hasOwnProperty(key)){
        value = Class.Mutators[key].call(this, value);
        if (value == null) return this;
    }

    if (typeOf(value) == 'function'){
        if (value.$hidden) return this;
        this.prototype[key] = (retain) ? value : wrap(this, key, value);
    } else {
        Object.merge(this.prototype, key, value);
    }

    return this;
};

This means when you pass a function, it will get wrapped automatically – wrapping enables you to have private methods via the .protect() decorator or special ones via .hide()

It also supports Class Mutators – you should check this but it’s ability to define special keys that can modify the constructor, as opposed to just add to the prototype.

Once again, you can easily do:

ClassConstructor.prototype.foo = someFn;

And this will work.

// but:
ClassConstructor.prototype.foo = someFn.protect();

// however...
instanceOfClassconstructor.foo(); // works also.

see this:

// generic method.
var foo = function() {
    console.log('hi');
};

var ClassConstructor = new Class({});

// implement the foo method as private.
ClassConstructor.implement({
    foo: foo.protect()
});

var instance = new ClassConstructor();

// try to call it, will throw.
try {
    instance.foo();
}
catch(e) {
    console.warn(e);
}

// do it directly on the prototype
ClassConstructor.prototype.foo = foo.protect();

var instance2 = new ClassConstructor();
instance2.foo(); // works.