Dynamic Object Handler

Language Chaos

Every language invented different rules. C++ uses virtual inheritance. Python has MRO linearization. Scala has trait linearization.

The complexity exploded. Developers couldn't predict behavior. Debugging became a nightmare.

The Great Retreat

Java banned it. C# followed. JavaScript never had it. Go rejected it from the start.

The mantra became universal: "Composition over inheritance."

Pattern('Animal', {
    moc: { 
        config: 'object', 
        classes: 'array' , 
        move: 'method'
    },
    config: { habitat: 'land' }, 
    classes: ['animal']
    move() { console.log('Animal is moving'); },
});

Pattern('Bird', 'Animal', {
    name: 'Bird', // Simple override (no moc rule needed)
    config: { wings: 2 }, 
    classes: ['flying']
    move() { console.log('Flying at 1000ft'); },
});

Pattern('Horse', 'Animal', {
    name: 'Horse', 
    config: { legs: 4 }, 
    classes: ['galloping']
    move() { console.log('Galloping at 40mph'); },
});

Pattern('Pegasus', ['Bird', 'Horse'], { name: 'Pegasus' });

Results:

• String overrides: name: 'Pegasus'
• Objects merge: config: {habitat:'land', wings:2, legs:4}
• Arrays combine: classes: ['animal','flying','galloping']
• Methods collaborate:

Animal is moving
Flying at 1000ft
Galloping at 40mph

This shows simple method stacking, but doesn't address ordering control, return value blending, or hooking (pre_move, post_move) that melded methods provide.

The Method Strategy Matrix

Method stacking is just the beginning. Real composition needs control over ordering, return handling, and lifecycle hooks.

Every method call follows the same blending intelligence that governs object construction—MOC rules applied at runtime. The composition strategy itself becomes part of your domain modeling.

Ordering

Add _Funnel to reverse any strategy. Chain_Funnel, Method_Funnel, Async_Funnel—direction matches purpose.

Return Values

Returns follow same MOC rules as construction. Method blends onto `this`, Chain pipes results, Blender respects type-aware merging.

Hooking

Every method gets pre_ and post_ hooks automatically. Setup, teardown, validation—lifecycle control built-in.

// Not "IS-A" or "HAS-A" but "DOES-ALL"
const component = New(['Draggable', 'Resizable', 'Clickable']);

// All behaviors are active and collaborative
// No conflicts, no ambiguity, no choosing sides

Each piece unlocked the next logical problem. As web standards matured, we leveraged what we could—JSON, Node.js, ESM. But the core insight remained: dependency-aware execution flow transforms everything it touches.