Object Membership
with Prototypes

Preface

Author Ondřej Pavlata Jablonec nad Nisou Czech Republic

Document date Initial release March 12, 2015 Last major release March 12, 2015 Last update March 12, 2015 (see Document history)

Warning

1. This document has been created without any prepublication review except those made by the author himself.

Table of contents

S1_ȷ: Object membership with prototypes

• Θ is a set of objects.
• O is a subset of Θ.
• ϵ is a relation between objects, the object membership.

Proposition A:

1. There is a one-to-one correspondence between S1_ȷ structures and S1_ϵ structures. For every S1_ϵ structure (Θ', ϵ), if Θ and O are subsets of Θ' given by
   • Θ = Θ'.ec.↥.↧   (that is, Θ equals Θ' without terminals), and
   • O = Θ'.ec   (that is, O are the eigenclasses of (Θ', ϵ)),
   then (Θ, O, ϵ) is an S1_ȷ structure. Conversely, every S1_ȷ structure (Θ, O, ϵ) is obtained from a uniquely given (up to isomorphism) S1_ϵ structure by the above prescription.
2. Up to isomorphism, the structure (Θ, ϵ) is uniquely given by (O, ϵ). However, the converse is false in general.
3. The set Θ ∖ O.ec forms a closure system in (Θ, ≤).
4. The S1_ϵ structure (O, …) is a substructure of (Θ, …) with respect to the signature (Θ, .ec, ≤).

• Let (instance) prototypes be the objects from Θ ∖ O.
• Let eigenclasses be the objects from O.ec. For x ∈ Θ ∖ O we avoid saying that x.ec is the eigenclass of x.
• Let front objects be the objects that are not eigenclasses.
• Let primary objects be the front objects that are not instance prototypes.
• Let T be the set of objects that are terminal in (O, ϵ).
• Let C be the set of objects that are classes in (O, ϵ).
• Let .c be the closure operator corresponding to the closure system Θ ∖ O.ec of front objects. That is, x.c is the least ancestor of x that is a front object.
• Let .class be the map .ec.c. Therefore, for an object x ∈ Θ, x.class is the least class from x.ec.↥.
• Let r be the inheritance root from (O, ϵ). We call r the class-inheritance root.
• Let c = r.class be the metaclass root or instance root. Descendants of c are metaclasses.
• The instance-of relation is the range-restrictiction of ϵ to C.
• The i-th metalevel, i ≥ 0, is the set r.ec(i).϶ ∖ r.ec(i).↧.
• For x ∈ O,
  • x.mli, the metalevel index of x, is equal to that in (O, ϵ). Otherwise (if x ∈ Θ ∖ O) x.mli = 0.
  • x.eci, the eigenclass index of x, is equal to that in (O, ϵ). Otherwise x.eci = -1. Prototypes are therefore the objects with a negative eigenclass index.
• The primary object map, .pr, is defined as an extension of (O, .pr) by .pr = .ec.pr. Therefore, the set Θ.pr of primary objects equals O.pr = T ⊎ C.

• Let H be the set of helix objects – objects x ∈ Θ such that x ϵ x.
• Let R be the reduced helix of (Θ, ϵ).
• The operators .he and .re are the closure operators corresponding to the closure systems H and R in (Θ, ≤), respectively.
• The inheritance root is the top of (Θ, ≤).
• The metalevel of an object x is the unique metalevel to which x belongs.

Proposition B:

1. Prototypes are the eigenclass predecessors of classes, Θ ∖ O = C.ce. If x equals y.ce for a class y, then we say that x is an (instance) prototype of y.
2. The relations (.ec) and (≤) commute, i.e.
   • (.ec) ○ (≤) = (ϵ) = (≤) ○ (.ec).
3. The .class map is an extension of the class map from (O, ϵ). For a prototype x, x.class equals x.ec.
4. Each prototype is a direct instance of its class. As a consequence, C = Θ.class.
5. The maps .class and .ce establish an order isomorphism between (Θ ∖ O, ≤) and (C, ≤), to and from, respectively. In particular, there is a one-to-one correspondence between instance prototypes and classes.
6. The maps .class and .ce form a Galois connection between (Θ, ≤) and (C, ≤), i.e. for every object x and every class y,
   • x.class ≤ y   iff   x ≤ y.ce.
   In particular, the instance prototype of a class y is the highest instance of y, w.r.t. ≤.
7. Prototypes form a closure system in (Θ, ≤) with .class.ce the corresponding closure operator. This way, the .class map is inherited from prototypes.
8. The set Θ of objects is a disjoint union of (the sets of) terminals, classes, prototypes and eigenclasses,
   • Θ = T ⊎ C ⊎ C.ce ⊎ O.ec.
9. The class-inheritance root r is the highest class. Its prototype r.ce is the highest object – the inheritance root.
10. The helix structure (H, ϵ) can be described by the following table:

    Metalevel index		0	>	1	>	2, 3, …
    Nomenclature		Prototypes		Classes		Eigenclasses
    Expression		H.class.ce		H.class		H.ec(2)
    Highest object		r.ce		r		r.ec
    ∶		∶		∶		∶
    Lowest object		c.ce		c		—

11. Every metalevel has a top. For an object x,
    • x.re is the top of the metalevel of x,
    • the metalevel of x equals x.re.↧ ∖ x.re.ec.↧,
    • the metalevel index of x equals x.re.eci + 1.

The instance-of relation

Proposition: The instance-of relation in S1_ȷ structures satisfies the following conditions:

1. (a) The instance-of relation equals (≤) ○ (.class). Note that this only possible because each class has a direct instance. This is generally not satisfied in S1_ϵ structures.
2. (b) For an object x and a class y,
   • x ϵ y   iff   x ≤ y.ce.
   That is, x is an instance of y iff x is a descendant of the instance prototype of y.
3. (c) Assume that all classes are at metalevel 1 (so that C is convex in (Θ, ≤)). Then statements (a) and (b) remain valid if ≤ is replaced by a suborder ≤' that is obtained from ≤ by removing strict inheritance between classes, i.e.
   • (≤') = (≤) ∖ (C, <).   (That is,   x ≤' y   iff   x ≤ y and x, y are not different classes.)
   Note that in (Θ, ≤'), every class has c.ce as a single parent.

Note: In JavaScript, the native core structure implements ≤' instead of ≤. The (b) condition is used for the interpretation of the instanceof operator.

S1_ȷ.c: The front structure

• Θ.c is a set of (front) objects.
• ≤ is a relation between objects, called inheritance.
• .class is a function between objects. For an object x, x.class is the class of x.
• .ce is a function from Θ.c.class (the image of .class) to Θ.c. For an object x, x.ce is the instance prototype of x.
• r is a distinguished object, the class-inheritance root.

• The (front) object membership relation, ϵ, is the composition (.class) ○ (≤), i.e. an object x is a member-of an object y iff x.class ≤ y.
• The usual notation and terminology for ≤ and ϵ applies, in particular, .↥/.↧ and .ϵ/.϶ are the respective image/preimage operators.
• Let C be the set Θ.c.class. Elements of C are classes. Elements of C.ce are (instance) prototypes.
• Let T be the set of remaining objects. Elements of T are terminal(s).
• By (S1_ȷ.c~5), C and C.ce are disjoint, so that Θ.c = T ⊎ C ⊎ C.ce.
• Let H.c be the set of all (front) objects x such that x ϵ x. Elements of H.c are (front) helix objects.
• Let c = r.class be a distinguished class, called the metaclass root or instance root.

Proposition:

1. An S1_ȷ.c structure is uniquely given by any of the following:
   • (Θ.c, .class, ≤).
   • (Θ.c, ϵ, ≤).
2. The restriction of an S1_ȷ structure to the set of front objects (i.e. objects that are not eigenclasses) is an S1_ȷ.c structure. That is, if (Θ, O, ϵ, ≤) is an S1_ȷ structure then (Θ.c, ϵ, ≤) is an S1_ȷ.c structure.

Sample A

• the inheritance ≤ is a tree   (that is, ≤ is a single inheritance), and
• all classes are in the metalevel 1.

• Class < Object < BasicObject

r = BasicObject
c = Class
A = Class.NEW()
B = Class.NEW(A)
s = A.NEW()
u = B.NEW()
v = B.NEW()

Implementation in JavaScript

Object naming

All objects are referred by non-global variables. The Object class is different from the built-in object constructor:

Basic links between objects

Note: The $class and $proto properties are created by the library. They are not built-in properties of JavaScript objects.

The following code shows the one-to-one correspondence between classes and instance prototypes. The built-in JavaScript inheritance is used to extend the .class map from prototypes to other objects (classes and terminals). In the sample structure, all classes reside at metalevel 1, so that their class is constantly Class, just like in Ruby. The jQuery utility method $.map is used to report the result of x.class for each object x in a list. For superclass links, the non-standard built-in __proto__ property is used. If not natively supported, the property is explicitly set.

Testing inheritance

Sample B

r = BasicObject
c = Class
M = Class.NEW(Object.ec(2))
N = M.NEW()
A = N.NEW()
B = N.NEW(A)
s = A.NEW()
u = B.NEW(); v = B.NEW()

Introspection tests

The native core structure of JavaScript

Notes:

• (⁎) By the ECMAScript standard, parent links are established via the [[Prototype]] internal property and can be introspected using the Object.getPrototypeOf method.
• (⁑) Not supported for objects created using the Function.prototype.bind method.

Sample α

r = Object
c = Function
A = new c
B = new c; B.prototype.__proto__ = A.prototype
s = new A
u = new B; v = new B

Sample β

r = Object
c = Function
e = eval
A = new c
B = new c; B.prototype.__proto__ = A.prototype
s = new A
u = new B
BB = B.bind({})
v = new BB

The instanceof operator

• x instanceof y     iff     y is a class such that x < y.ce.   (In the last expression, <' can be used as well.)

• x ϵ y     iff     x instanceof y   or   x === y.prototype.

Native objects

• Object.prototype.toString.call(x) === "[object " + name + "]"

Note: The primitive values x other than null and undefined are such that typeof x is either 'boolean', 'number' or 'string'. Using object wrapping, these values can be considered to be native objects.

Introspection

Notes:

1. The variables x and y in the above JavaScript expressions are only allowed to refer to native objects according to the previous subsection.
2. The instanceof operator as well as the isPrototypeOf method require a wrapper to work with primitive values.
3. As of ECMAScript, 5th Edition, the inheritance parent of x can be obtained by Object.getPrototypeOf (Object(x)).
4. Instances of the instance root c can be any of the following:
   • Classes from Ō.class.
   • Classes from C ∖ Ō.class – those created using the bind method.
   • The c.ce prototype.
   • Terminal objects – the built-in native methods.
   There is no built-in support to distinguish between all these groups in a simple way.

Assumptions

• As already mentioned, the set Ō is assumed not to contain host objects and the primitive values null and undefined.
• There is only one global object.
• Properties of the global object that refer to helix classes are not changed.
• The prototype property of an object is never changed.
• The constructor property is never changed.
• The __proto__ property (or the argument x of the Object.create(x) function) is only allowed to be set to a prototype different from Function.prototype.

New class creation

• (A) By changing the __proto__ property of y.prototype. This transition is atomic but non-standard.
• (B) By replacing the instance prototype of the newly created class y with a new instance x of the requested parent class. Subsequently, the value x.constructor has to be set to y so that the prototype↔class correspondence is established between x and y. This transition is supported by standard but is not atomic.

Built-in native classes

References

Document history

License