Metameta is meta core and meta-class programming framework.
# install from npm
> npm install @aimingoo/metameta
# OR, install from github
> npm install aimingoo/metametaAnd use in javascript
// Meta core
var {Meta, MetaClass, MetaObject} = require('@aimingoo/metameta');
// Helper methods, all home object safed.
var {isMeta, isAtom, asAtom} = Meta;
// learn case
var Objext = Meta.from(Object);
console.log(Objext.keys(new Objext)); // []
console.log(Meta.isAtom(new Objext)); // trueThe atom is smallest unit of pure object in javascript, it's object but not inherited from Object(). An atom is a object. null, Object.prototype, argumentsnamespace are atom objects in javascript language.
> Meta.isAtom(null);
true
> Meta.isAtom(Object.prototype)
trueatom created by meta, so the meta is constructor of atoms, with Atom() on the concept is the same. meta is base unit of Meta system, and is function always.
# meta is same of Atom()
> meta = new Meta;
# atom created
> atom = new meta;
# check is atom
> Meta.isAtom(atom);
true
# check is object
> typeof atom;
'object'Meta is meta's class.
// extend
class MetaX extends Meta {};
var meta = new MetaX;
// meta is atom too.
console.log(Meta.isAtom(new Meta)); // true
console.log(Meta.isAtom(meta)); // true
// instance from meta, check inheritance
var x = new meta;
console.log(x instanceof meta); // true
console.log(x instanceof Meta); // true
console.log(x instanceof MetaX); // true
// another
class MetaX2 extends Meta {};
console.log(x instanceof MetaX2); // falseMetaClass is root of Meta-classes programming system.
// meta-classes
class MetaClassEx extends MetaClass {
// ...
}
// extend meta system
// NOTE: must extends from a meta/Atom
class AtomObjects extends new MetaClassEx() {
// ...
}
// check
console.log(MetaClass.isClassOf(MetaClassEx)); // true
console.log(MetaClassEx.isClassOf(AtomObjects)); // true
console.log(MetaClassEx.isClassOf(new AtomObjects)); // true
// another
console.log(MetaClassEx.isClassOf(new MetaObject)); // falseMetaObject is a meta of MetaClass, and is a Class/Atom-constructor of atoms.
// MetaObject is defined in metameta
var obj = new MetaObject;
console.log(Meta.isAtom(obj)); // true
// extend object system
class MetaObjectEx extends MetaObject{}
// create atom
var x = new MetaObjectEx;
// check
console.log(MetaClass.isClassOf(MetaObject)); // true
console.log(MetaClass.isClassOf(MetaObjectEx)); // true
console.log(MetaClass.isClassOf(x)); // true
// check in pure javascript
console.log(x instanceof MetaObject); // true
console.log(x instanceof MetaObjectEx); // true
console.log(x instanceof MetaObject); // true
console.log(x instanceof MetaClass); // true
console.log(x instanceof Meta); // true
// more
var isPrototypeOf = (...args) => Object.prototype.isPrototypeOf.call(...args);
console.log(isPrototypeOf(MetaObject, MetaObjectEx)); // true
console.log(isPrototypeOf(MetaClass, MetaObject)); // false
console.log(isPrototypeOf(MetaClass, MetaObjectEx)); // falseA shadow is meta from native constructor.
// shadow from native-constructor
var Objext = Meta.from(Object);
// shadow is meta
var x = new Objext;
console.log(Meta.isAtom(x)); // true
// shadow has static methods from source
console.log(Objext.keys(x)); // []# pull source
> git clone https://github.com/aimingoo/metameta
> cd metameta
> npm install
# test
> npm test
# coverage
> npm -g install istanbul
> npm run coverage-
Meta's Class methods
// Return a object is atom object // @param {object|function} - a object Meta.isAtom(x) // Return a new atom/Atom, it's proxy of x, and prototype by base. // @param {object}[object] - a atom base another atom object // @param {function}[function=Atom] - a meta base meta/Meta/Atom... Meta.asAtom(x, base) // Return a class is Meta // @param {function} - a class Meta.isMeta(cls) // Return a shadow meta for native-constructor // @param {function} - a native constructor Meta.from(constructor)
-
MetaClass's Class methods
// Return the class is base of x // @param {object} - is instance of class // @param {function} - is sub-class of class MetaClass.isClassOf(x)
-
extends from Meta
class MetaX extends Meta {}
-
meta's extends
// Meta-classes programming framework based class X extends new MetaClass {} // OR class X extends new MetaX{}
2018.08.17 - v0.9.1 released, happy Chinese traditional valentine's day.