Preface

Author Ondřej Pavlata Jablonec nad Nisou Czech Republic

Document date Initial release March 2, 2011 Last major release June 21, 2012 Last update October 10, 2012 (see Document history)

Warning

1. This document has been created without any prepublication review except those made by the author himself.
2. The author is not an experienced Ruby programmer. In fact, he did not write any Ruby program except very simple tests.
3. Most of the author's experience with dynamic programming languages comes from JavaScript.

Ruby version

Table of contents

Preliminaries

Monounary algebra

• X is a set,
• .p¯ is a function X → X.

We denote x.p(i) the i-th application of .p to x (we put x.p(0) = x). A subset C ⊆ X is called a

• cycle if it is of the form C = {x, x.p(1), …, x.p(n)} such that 1 ≤ n and x = x.p(n+1) (in particular, C is finite).
• ω-chain if it is of the form C = {x, x.p(1), x.p(2), …, } where x.p(i) ≠ x.p(j) for i ≠ j, i.e. (C, .p) is isomorphic to the succession structure of natural numbers (in particular, C is infinite).
• component if it is a component of (X, .p) as a relation, i.e. C is maximal such that for every x, y ∈ C there are i, j such that x.p(i) = y.p(j).

A structure is said to be locally finite if its every finitely generated substructure is finite. For a (partial) monounary algebra (X, .p) it means that for every x ∈ X, the set {x, x.p(1), x.p(2), …, } is finite.

Proposition: Let (X, .p¯) be a connected (total) monounary algebra.

1. Either (a) or (b) occurs:
   • (a) X contains exactly one cycle and no ω-chains.
   • (b) X contains no cycle and an ω-chain (consequently, infinitely many ω-chains).
2. The case (a) occurs iff (X, .p¯) is locally finite.
   (In particular, every finite connected monounary algebra has exactly one cycle.)

Pseudotree

The following picture shows a pseudotree with a 4-element pseudoroot C. An arrow x → y means x.p¯ = y.

• r.p¯_r = r,
• x.p¯_r = x.p¯ whenever x ≠ r,

Algebraic forest

1. (1) A partial order whose every principal up-set is a finite chain:
   A partial order (X, ≤) such that for every x ∈ X, the set x.ps = { y ∈ X | x ≤ y } is finite and totally ordered by ≤.
2. (2) A monounary algebra whose every non-empty subalgebra has a fixed point:
   An algebra (X, .p¯) with just one unary operator, .p¯ : X → X, such that for every x ∈ X, x.p¯(i) = x.p¯(i+1) for some natural i.
3. (3) A partial monounary algebra without total non-empty subalgebras:
   A partial algebra (X, .p) with just one partial unary operator, the parent partial function .p: X ↷ X, such that for every x ∈ X, x.p(i) is defined for only finitely many i.

1. x is .r-closed,
2. x is a fixed point w.r.t. .p¯,
3. x has undefined parent x.p.

Notes:

1. We consider the partial order form (1) as the primary one so that we usually prepend the phrase reflexive transitive closure of when referring to algebraic forests of form (2) or (3).
2. The form (3) shows that an algebraic forest can be viewed as a special case of a directed acyclic graph (DAG) which in turn is a special case of a digraph (a directed graph). In this context the term algebraic forest is equivalent to that of a rooted forest [].

Algebraic tree

1. (X, .p¯) is an algebraic forest,
2. r is the only fixed point of .p¯.

Proposition:

A structure (X, .p¯, r) is an algebraic tree iff (X, .p¯) is a pseudotree with the pseudoroot being the singleton set {r}.

Primorder algebra

• X is a set,
• .ec is a map X → X, x.ec is called the eigenclass of x,
• .pr is a map X → X, x.pr is called the primary element of x.

• (1) .ec is injective.
  We denote .ce the inverse of .ec. If defined, x.ce is the (direct) eigenclass predecessor of x.
• (2) The partial algebra (X, .ce) is a forest with the root map equal to .pr.

Proposition:

1. Each component of the monounary algebra (X, .ec) is isomorphic (via .eci) to the structure (ℕ, succ) of natural numbers where succ is the successor operator.
2. X = X.pr ⊎ X.ec, i.e. an element is either primary or an eigenclass.
3. For an element x the following are equivalent:
   • x is primary.
   • x is the primary element of itself.
   • x has no eigenclass predecessor.
   • x has zero eigenclass index.
4. A primorder algebra (X, .ec, .pr) is uniquely given by its reduct (X, .ec).

State transition system

• C is a state domain which is a set-theoretic class of (many-sorted) structures with a common signature, elements of C are states,
• Act is an action domain which can be written as Act = Λ × P where
  • Λ is a label domain,
  • P is a transition parameters domain consisting of finite lists of elements from domains of sorts of C,
• T is a transition relation which is a subset of C × Act × C,
• r is an element of C called the inital state.

Data structure description pattern

• The word structure refers to an algebraic structure, or, more precisely, structures form set-theoretic class C of algebraic structures with equal signature.
• The word system refers to a state transition system with state domain C. This system induces a subdomain D of reachable states which specifies the data structure for a particular level of abstraction.
• The word system refers to incremental specification. We start with a most abstract description of the Ruby object model and provide subsequent descriptions by a refinement of previous ones.

1. The outer evolution refers to our incremental description.
2. The inner evolution is relevant to Gurevich's concept of evolving algebras [] [] [].

Note: We always aim at C being the closest approximation of D as possible so that the data structure is as little determined by transitions as possible.

S0: 2x2 nomenclature

• There are objects that are not instances but are instances of other objects.
• The class Class has no instances. (This is in contradiction with most of present Ruby literature.)

• Singleton classes are not classes.

• O is a set of (all) objects,
• .terminative? and .primary? are boolean attributes of objects indicating whether an object is terminative resp. primary.

S1: Inheritance and primorder

• O is a set of (all) objects.
• .ec is a total function between objects, x.ec is called the eigenclass of x.
• .pr is a total function between objects, x.pr is called the primary object of x.
• .sc is a partial function between objects, x.sc (if defined) is called the superclass of x.
• r is an object, called the inheritance root.
• c is an object, called the instance root or metaclass root (by (S1~7), c is a shorthand for r.ec.sc).

• We say that an object is primary if it is the primary object of itself.
• We say that an object x is terminative if x.pr is not r and x.pr.sc is not defined.
• Having specified the sets of primary objects and terminative objects, the 2x2 nomenclature is defined (so that S0 is a reduct of a conservative extension of S1). In particular, the partition of objects into terminals, classes and eigenclasses is specified (corresponding to boolean attributes .terminal?, .class? and .eigenclass?, respectively).
• x.sc(i) (resp. x.ec(i)) denotes the ith application of .sc (resp. .ec) to x (we allow 0th application whenever the 1st application is defined).
• The reflexive transitive closure of the superclass partial function .sc (with the reflexive closure only applied to non-terminals) is denoted ℍ and called the (.sc-) inheritance.
• The reflexive transitive closure of the eigenclass function .ec is denoted ℙ and called the primorder.

Proposition:

1. c is a class.
2. Classes form an algebraic subtree of the inheritance tree, i.e.
   • r is a class.
   • For every non-root class x, x.sc is a class.
3. Classes together with first eigenclasses of terminals form an algebraic subtree of the inheritance tree which uniquely determines the inheritance tree.

The subclass-of relation

Eigenclass index

Proposition: The superclass operator .sc decrements the eigenclass index on (all) eigenclasses of terminals and on (all) eigenclasses of the inheritance root r. On other objects, the index is preserved. I.e. for every object y for which y.sc is defined,

• (a) y.sc.eci == y.eci - 1 if y.pr equals either r or some terminal,
• (b) y.sc.eci == y.eci otherwise.

Inheritance ancestor lists

1. x.hancs is defined iff x is non-terminal,
2. x.hancs[i] == y iff x.sc(i) == y.

Metaclasses

• explicit if it is a class, and
• implicit otherwise (i.e. if it is an eigenclass).

Note: The explicit/implicit terminology is redundant. We could use the primary/secondary terminology established in the 2x2 nomenclature.

Observations:

• The metaclass root c is the only explicit metaclass.
• An object is an implicit metaclass iff it is an eigenclass of a non-terminal object.
• Implicit metaclasses form a subtree in the inheritance, rooted at r.ec.

Primary inheritance

Obviously, .ec_sc_pr is an algebraic tree. For every primary x,

• x.ec_sc_pr == x.sc if x is a class,
• x.ec_sc_pr == x.class == x.ec.sc if x is a terminal (*).

Note: (*) The .class map is defined later.

The front pseudotree

The S1_₀₁ substructure

• O₀₁ is the set of objects with eigenclass index equal to 0 or 1,
• .sc is the restriction of the superclass partial map to O₀₁,
• .ec is the restriction of the eigenclass map to primary objects – so that .ec is only partial in S1_₀₁ (and is a bijection between primary objects and first eigenclasses).

Proposition: Up to isomorphism, an S1 structure is uniquely determined by its S1_₀₁ substructure.

The Ruby Helix

We call the minimum S1 substructure Ruby helix. The name comes from the fact that the substructure resembles a helical threading of a right-infinite screw. The inheritance corresponds to the helix curve, the primorder corresponds to imaginary lines parallel to the screw axis. This is stated more precisely as follows.

Proposition:

1. Ruby helix consists of classes c.hancs and their .ec chains. In particular, Ruby helix contains no terminals.
2. When restricted to the helix, .sc is injective.
3. Let n be the number of helix classes, i.e. n = c.hancs.length. Then x.ce == x.sc(n) for every helix eigenclass x.

Helix classes

Class < Module < Object < BasicObject.

A sample S1 structure

class A; end; class B < A; end; b = B.new   (cf.[])

The .class function alias direct-instance-of relation

• x.class == x.ec.sc if x is terminal,
• x.class == r.ec.sc (== c) otherwise.

Proposition: For every object x, x.class equals the entry-object of the class subtree when traversed from the eigenclass of x, i.e. x.class == x.ec.hancestors[0].

For objects x, y, if x.class == y then we say that y is the class of x and that x is a direct instance of y. The reflexive transitive closure of .class is an algebraic tree with a 2-3 level structure shown in the following table (we use the name Class for the instance root c).

The instance-of relation

Proposition: x is an instance-of y   iff   x.ec.hancestors contains y.

State transitions

In addition, we use the following notational conventions: By saying that S → S' is a state transition we mean S and S' are abstract states with S appearing before S' in the run. We use state indices or apostrophes to distinguish between structures for particular states, e.g. Oi denotes the set of objects of Si.S1. We drop underscores whenever no confusion is likely to arise, so that Oi means Oi.

The following rules apply:

Creating new objects

• The requested value of x.ec.sc.pr (i.e. the parent in the primary inheritance .ec_sc_pr – necessarily a class).
• The requested terminality of x - i.e. whether x should be (a) a terminal or (b) a class.

• (a) x = X.new. This creates a new terminal x.
• (b) x = Class.new(X). This creates a new class x.

Removing existing objects

Instantiable classes

• there is an object x such that x is instance-of y.

Final classes

• y has no subclasses, and
• this condition is preserved by transitions.

Note: The Class class is final (due (S1~8)).

Quasifinal classes

• y does not have instantiable subclasses, and
• this condition is preserved by transitions.

Proposition:

1. Final classes are quasifinal.
2. Except for Class, quasifinal classes are those that cannot have indirect instances.

Note: The Symbol class is quasifinal (due (S3~4)).

S2: Module inclusion lists

• m is a class, called the root metamodule,
• .incs is a partial function from the set O of objects to the set of (finite) lists of objects.

An S2 structure has the following (additional) axioms:

Includers

Proposition: An object is an includer   iff   it is an instance of Module.

The own-includer-of relation

The reflexive closure, restricted to includers, of the own-includer-of relation is denoted by Μ.

Pure instances

The HM descendancy

1. ℍ is the .sc-inheritance, and
2. Μ is the reflexive closure of the own-includer-of relation.

1. x == y,
2. x.sc(i) == y for some i,
3. x.incs[i] == y for some i,
4. x.sc(i).incs[j] == y for some i, j.

Proposition:

1. The restriction of descendancy to non-terminals equals the .sc-inheritance.
2. Contrary to the semantic convention for the ≤ symbol, HM descendancy is not a partial order in general. Neither transitivity nor acyclicity (antisymmetry of the transitive closure) is guaranteed. (See Inclusion anomalies for examples.)
3. For every includers x, y such that x ≤ y,
   • x not being an eigenclass implies y not being an eigenclass,
   • x being a module implies y being a module.

The includer-of relation

• x is an includer of y  iff  x < y and y is a module.

Proposition: The includer-of relation is an extension of the own-includer-of relation.

The kind-of relation

• x is kind of y  iff  x.ec ≤ y.

Proposition:

1. An object cannot be kind of a pure instance.
2. An object is kind of its eigenclass.
3. The instance-of relation is a range-restriction of the kind-of relation to classes.

If X is an includer then Xs means the set of objects that are kind of X. This convention is usually applied to named classes or modules.

Notes:

• The word kind in the phrase (l) is kind of (r) construes with the right side of the phrase, so that we cannot express Xs as kinds of X.
• If X is a class then Xs means instances of X.

Basic kinds

• A class is not a module and vice versa. (Modules ∩ Classes == ∅.)
• Every class is kind of Module. (Classes ⊂ Modules.)
• No module is kind of Class. (Modules ∩ Classes == ∅.)

Note: Another diagram of the nomenclature is provided as a side view of an example of the S2 structure. This diagram is a refinement of the 2x2 nomenclature table.

Objects versus Objects

An S2 structure example

Note: (∗) Each of the 5 division lines partitions the set of objects into two complementary subsets, specified as <set> / <complemetary set>.

class S < String; end; class A; end; class B < A; end; class X < Module; end

module R; end; module M; end; N = X.new

s = S.new; i = 20; j = 30; k = 2**70; b = B.new

class BasicObject; include ::R           end
class B;           include M             end
class << B;        include M             end
class X;           include M             end
class << X;        include M             end
module N;          include M, Comparable end
class << s;        include N             end

The diagram shows that inclusion lists refine the sc-inheritance. This refined structure is refered to as MRO in the next section. Ancestor lists in the structure can be reported (without eigenclasses) by the following code (show result).

class Object; def ec; singleton_class rescue self.class end end

%w{s i j k b    }.each { |x| puts "%s.ec: %s" % [x, eval(x).ec.ancestors] }
%w{B.ec X.ec N X}.each { |x| puts    "%s: %s" % [x, eval(x).ancestors] }

s.ec: [N, M, S, String, Comparable, Object, Kernel, BasicObject, R]
i.ec: [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject, R]
j.ec: [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject, R]
k.ec: [Bignum, Integer, Numeric, Comparable, Object, Kernel, BasicObject, R]
b.ec: [B, M, A, Object, Kernel, BasicObject, R]
B.ec: [M, Class, Module, Object, Kernel, BasicObject, R]
X.ec: [M, Class, Module, Object, Kernel, BasicObject, R]
N: [N, M, Comparable]
X: [X, M, Module, Object, Kernel, BasicObject, R]

The method resolution order (MRO)

MRO domain

1. Pairs (x,x) with x being an includer (includer elements).
2. Pairs (x,y) with y being a member of x.incs (iclass elements, y is necessarily a module).

MRO .super

1. For pairs (x,x),
   1. (x,x).super == (x.incs[0], x) if x.incs is nonempty, else
   2. (x,x).super == (x.sc, x.sc) if x.sc is defined, else (x,x).super is undefined.
2. For pairs (x,y) with x different from y,
   1. (x,y).super == (x, x.incs[i+1]) if y equals x.incs[i] for some i < x.incs.length-1, else
   2. (x,y).super == (x.sc, x.sc) if x.sc is defined, else (x,y).super is undefined.

MRO

Proposition:

1. (x,y) ≤ (a,b)  iff  (x,y).super(i) equals (a,b) for some i, i.e. (Μ, ≤) is a reflexive transitive closure of (Μ, .super).
2. The method resolution order is an algebraic forest.
3. MRO consists of two types of components:
   1. (A) There is a unique component containing (r,r), called the MRO tree. Its root equals either (r,r) or (r, r.incs.last).
   2. (B) All the remaining components are chains corresponding to inclusion lists of a module includer extended by the includer itself.

MRO ancestor lists

1. x.ancs[i] == y iff (x,x).super(i) == (w,y) for some w.

The Ruby .ancestors built-in method filters out eigenclasses: For each class or module x, x.ancestors equals x.ancs without eigenclasses.

Proposition: Let x, y be includers.

1. x ≤ y iff x.ancs contains y.
2. • x.ancs == [x] + x.incs + x.sc.ancs if x.sc is defined,
   • x.ancs == [x] + x.incs otherwise (i.e. if x is a module or equals r).
3. (x,y) is in Μ   iff   y is in x.ancs and only modules appear before the first occurrence of y in x.ancs.
4. (x,y) is in ℍ   iff   y is in x.ancs and is not a module.
5. For any non-terminal x, the inheritance ancestor list x.hancs is obtained from x.ancs by removing modules.
6. If x is not an eigenclass then x.ancs does not contain an eigenclass (i.e. x.ancs == x.ancestors).

A note about terminology

S2 transitions

The following rules apply:

Proposition:

1. Transitions preserve HM descendancy, MRO, includer-of and kind-of relations in the following weak sense:
   • If x ≤ y in S then x ≤ y in S'.
   • Similarly for the includer-of and kind-of relations.
2. Transitions do not preserve the above relations in the strong sense in general - the relations in S are not necessarily restrictions of their counterparts in S'. In particular, for an includer x,
   • the MRO parent (x,x).super can differ between S and S'. (Note that it is in contrast to the superclass (partial) function .sc.)

Module inclusion

• A requested includer p.
• A requested includee q.

• (a) q is a module – otherwise an error wrong argument type is raised.
• (b) p does not occur in [q] + q.incs (== q.ancs) – otherwise an error cyclic include detected is raised.

• l0 = (s0 - p.ancs) + t0 where s0 and t0 are maximum prefixes (initial sublists) of [q] + q.incs and p.incs, respectively, that are disjoint from A.
• li = [ai] + (si - p.ancs) + ti,   i = 1, …, n, where [ai] + si and [ai] + ti are maximum slices (interval sublists) of [q] + q.incs and p.incs, respectively, that are disjoint from A - [ai].

In most cases, A is empty, so that

• p.incs' == [q] + (q.incs - p.ancs) + p.incs,

T0, T1, T2, S0, S1, S2, A1, A2 = Array.new(8).map { Module.new }

module P; include T0, A1, T1, A2, T2 end
module Q; include S0, A2, S2, A1, S1 end

module P; include Q                  end

p P.included_modules    #--> [Q, S0, T0, A1, S1, T1, A2, S2, T2]

Inclusion methods

The extend method of Kernel provides a shorthand for inclusion into eigenclasses: x.extend(M) is roughly equivalent to class << x; include M end. Each of include and extend might be considered outer methods of the form

• <outer-method> == <inner-method> + <hook-method>

module M; end
class << M
  def append_features(x); puts "inner: #{self} as includee of #{x}"; super end
  def included(x);        puts "hook:  #{self} as includee of #{x}" end
  def extend_object(x);   puts "inner: #{self} as extender of #{x}"; super end
  def extended(x);        puts "hook:  #{self} as extender of #{x}" end
end
class X; end
x = X.new

class << x; include M end   # inner: M as includee
                            # hook:  M as includee
x.extend(M)                 # inner: M as extender
                            # hook:  M as extender

Notes:

• Outer methods have the includer as a receiver.
• Inner methods have the includee as a receiver.
• Outer methods allow for multiple arguments. As already demonstrated in the previous subsection, the argument order is inverse to the performed inclusion order so that the argument order coincides with the inclusion list order [].

Inclusion anomalies

1. Module inclusion is not necessarily commutative.
2. The includer-of relation can be non-transitive. i.e. HM descendancy is not transitive in general.
3. The includer-of relation can have cycles, i.e. HM descendancy is not antisymmetric in general.
4. MRO ancestor lists can be repetitive (in contrast to sc-inheritance ancestor lists).

Examples:

• An example code of module inclusion non-commutativity.

  module A; end; module B; end; module C; end
  ↙	↘
  module A; include B end module B; include C end	module B; include C end module A; include B end
  ↘	↙
  p A.included_modules
  #=> [B]	#=> [B,C]

• An example code of non-transitive inclusion. A non-transitive triple (A,B,C) is created. (The red-framed case of the previous example.)

  module A; end; module B; end; module C; end
  
  module A; include B end
  module B; include C end
  
  puts "%p, %p, %p" % [A < B, B < C, A < C] #=> true, true, nil
  

• An example code of an inclusion cycle.

  module L;           end
  module M; include L end
  module A;           end
  module L; include A end  # M does not know about this
  
  module A; include M end  # inclusion cycle A < M < L < A created
  
  puts "#{A.include? L}, #{L.include? A}" #=> true, true
  puts "#{A < L}, #{L < A}"               #=> true, true
  

• An example code of a repetitive ancestor list.

  module M;              end
  class X;               end
  class Y < X; include M end
  class X;     include M end
  
  p Y.ancestors  # [Y, M, X, M, Object, Kernel, BasicObject]
  

V1: Value domain

• O is the already introduced set of objects.
• Φ is a value domain, disjoint from the set O of objects.
• ΦA is a subset of Φ, elements of ΦA are called atomic.
• FALSE and TRUE are distinct elements of ΦA, having the semantics of boolean values.
• NULL and UNDEF are distinct elements of ΦA, indicating undefinedness.
• ℤ is a subset of ΦA representing the set of integer numbers.
• ℱ is a subset of ΦA (disjoint from ℤ) representing the set of floating point numbers.
• ℬ is a subset of ΦA. It is a set of bytestrings which are finite sequences of bytes. A byte can be considered a copy of an integer within the 8-bit range 0, …, 255. Bytes corresponding to the 7-bit range of 0, …, 127 are called ascii.
  We assume the usual free monoid structure (ℬ, +, '') where
  • + is bytestring concatenation,
  • '' is the empty bytestring.
• .φvalue is a partial function from O to Φ assigning objects their semantic value.

Note: Gray color indicates that merging V1 and S2 structures yields a single meaning for the O symbol.

The following condition is required:

Note:

• (V1~1) allows certain objects to be φvalued:
  • Symbols and Strings are φvalued by pairs from ℬ × ℬ (via estrings).
  • Rationals are φvalued by pairs from ℤ × ℤ.

S3: Immediate values

• (A) (FalseClass, TrueClass, NilClass, false, true, nil) where
  • The first 3 members are classes, direct descendants of Object.
  • The latter 3 members are their respective direct instances.
• (B) (Fixnum, Integer, Numeric) where
  • Fixnum, Integer and Numeric are classes such that Fixnum < Integer < Numeric < Object is a direct inheritance chain.
  Instances of Fixnum are caled fixnums.
• (C) (Symbol, Υ) where
  • Symbol is a class, a direct descendant of Object.
  • Υ denotes the set of Symbol instances (Symbols).
  Elements of Υ are called symbols.

The structure is subject to the following axioms:

Notes:

• (S3~2) means that identity of immediate values is given by their φvalues.

Transitions

S4: Actuality

• .actual? is a boolean attribute of objects.

The structure is subject to the following axioms:

Conventional extent(s)

• conventional extent, or simply that actuality is conventional, if Oa ⊆ O₀₁, i.e. if only primary objects and (some) first eigenclasses are actual (equivalently, eigenclasses of eigenclasses are not actual),
• (the) Smalltalk extent, if Oa equals the set (primary objects) ⊎ ((first) eigenclasses of classes). Note that this a special case of conventional actuality.

Actual lists

Note that under conventional actuality, x.actuals.length ≤ 2 for every primary object x.

Helix actuals

Proposition:

• The metaclass r.class.actuals.last is the least actual helix object in the inheritance.
• Under conventional actuality, helix actual lists are of length 2 (r.actuals.length == 2).

The actualclass map

1. x.aclass == x.ec if x.ec is actual, else
2. x.aclass == x.ec.sc (== x.class) if x is terminal, else
3. x.aclass == x.sc.aclass.

Proposition:

1. For every actual object x,
   1. x.aclass equals the first actual member of x.ec.hancs,
   2. (x.class ==) x.ec.hancestors[0] == x.aclass.hancestors[0].
2. The .aclass map forms an algebraic tree – the actualclass tree.
3. The root of the actualclass tree equals r.class.actuals.last.
   • Under conventional actuality, it equals Class.ec.
4. The depth of the tree equals r.actuals.length + 1 (3 under conventional actuality).

Example: Assume conventional actuality and let A be a direct subclass of Object and a a direct instance of A. Then there are four possible .aclass chains from a to Class.ec according to whether a.ec and A.ec are actual or not.

The .ec ≤ .aclass ≤ .class refinement

Proposition:

1. For every object x,   x.ec ≤ x.aclass ≤ x.class.
   (The maps .ec, .aclass and .class form a chain when ordered pointwise by the HM descendancy.)
2. For every object x,

   x.ec	is the first member of x.ec.hancs,
   x.aclass	is the first member of x.ec.hancs	that is actual,
   x.class	is the first member of x.ec.hancs	that is a class.

   Note: Gray color indicates that statements are valid for both .hancs and .ancs.

3. Any .f of the .ec, .aclass or .class maps is monotone with respect to the inheritance ℍ, i.e. for every non-terminals x, y,   x ≤ y implies x.f ≤ y.f.
4. For every object x and every i > 0,   x.ec(i) ≤ x.aclass(i) ≤ x.class(i).

Semiactuals

1. x.saec is defined iff x is
   1. a class or
   2. a terminal such that x.actuals.length > 2.
2. If x.saec is defined then it equals x.actuals.last.ec.

We also introduce a 3-valued attribute of .actuality which is defined on all objects according to the table below.

The .klass map

1. (A) Restricted version: .klass is a partial map between actual objects. For every actual object x,
   1. (1) x.klass == x.ec if x.ec is actual, else
   2. (2) x.klass == x.ec.sc (== x.class) if x is terminal, else
   3. (3) x.klass is undefined.
2. (B) Full version: .klass is a map between actual or semiactual objects defined according to the MRI 1.9 implementation. For every actual or semiactual object x,
   1. (1) x.klass == x.ec if x.ec is actual or semiactual, else
   2. (2) x.klass == x.ec.sc (== x.class) if x is terminal, else
   3. (3) x.klass == x.sc.ec if x.pr is terminal and x is actual or semiactual, else
   4. (4) x.klass == c.ec(x.eci) (if x.pr is a class and x semiactual – the value is probably unimportant).

Proposition:

1. In its restricted version, the .klass map is a restriction of both the .aclass and the full version of .klass.
2. The restricted version of .klass is a generator of .aclass in the following sense: For every actual x,
   • x.aclass == x.klass if x.ec is actual or x terminal,
   • x.aclass == x.sc.aclass otherwise.

Transitions

Eigenclass actualization

• x - an actual object whose eigenclass x.ec is requested to be made actual.

1. (A) With (S4X~1) imposed:
   1. (1) x.acdelta == [] if x.ec is actual, else
   2. (2) x.acdelta == [x.ec] if x is terminal, else
   3. (3) x.acdelta == [x.ec] + x.sc.acdelta if x.pr is a non-helix class, else
   4. (4) x.acdelta == r.class.hancs.map{|c| c.ec(x.eci+1)} if x.pr is a helix class, else
   5. (5) x.acdelta == [x.ec] + x.sc.ec.acdelta if (x.pr is terminal and) x.eci != 1, else
   6. (6) x.acdelta == [x.ec] + x.sc.acdelta + x.sc.ec.acdelta (if x is the eigenclass of a terminal).

   Note: The recursive definition in (5) and (6) requires that x.acdelta is defined also for non-actuals.

2. (B) Without (S4X~1):
   1. (1)–(4) as in (A).
   2. (5) x.acdelta == [x.ec] + x.sc.acdelta (if x.pr is terminal) – the same prescription as in (3) applies.

Proposition: In case (B), x.acdelta, as a set, equals the union of the following (possibly empty) sets Δ1 and Δ2 (all functions are taken in S):

1. Δ1 equals x.ec.hancs - x.aclass.hancs.
2. Δ2 equals
   1. r.class.actuals.last.ec.hancs - y.hancs if y is the .sc-least helix object of Δ1, or
   2. empty set, if Δ1 does not contain a helix object.

The following examples of Ruby code show several ways of x's eigenclass actualization.

1. (A) Opening or explicitly referencing x.ec.
   1. (1) class << x; end
   2. (2) x.singleton_class
2. (B) Extending x.ec's inclusion list (or attempting extension).
   1. (1) x.extend(Module.new)
   2. (2) x.extend(Kernel) (including an already included module)
3. (C) Defining x.ec's own method (aka singleton method of x)
   1. (1) def x.dummy; end
   2. (2) x.instance_eval { def dummy; end }
   3. (3) x.define_singleton_method("", lambda{})
   4. (4) x.module_function(:m) (if x is a module having own method m)

Notes:

• None of (A)–(C) is applicable to immediate values (an error can't define singleton is raised).
• In addition, (C) is not applicable to Numerics that are not Fixnums (an error can't define singleton method is raised).

The built-in T_CLASS counter

1. classes,
2. actual eigenclasses, and
3. semiactual eigenclasses.

module Kernel
  def nnt_delta     # number of non-terminals delta
    @nnt ||= 0
    nnt = ObjectSpace.count_objects[:T_CLASS]
    delta = nnt - @nnt
    @nnt = nnt
    delta
  end
  def nnt_delta_report; puts "nnt_delta: #{nnt_delta}" end
end

nnt_delta_report  # nnt_delta: 387
class X; end
nnt_delta_report  # nnt_delta: 2

Proposition: Assuming (S4X~1), for every actual x which is not an immediate value, x.acdelta.length equals

1. nnt_delta - 1 if x.eci == 1, x.pr is terminal and x.pr.actuals.length == 2,
2. nnt_delta otherwise.

S5: Includer containment

• .cparent is a partial function between includers,
• .cname is a partial function from includers to symbols.

• The reflexive transitive closure of .cparent is called includer containment or just containment and denoted Ϲ.
• x.cparent, if defined, is called the containment parent of x.
• x.cname, if defined, is called the (containment) name of x.
• Includers with a containment name are named, the remaining are anonymous.
• Includers without containment parents are containment roots.
• x.cparent(i) denotes the i-th application of .cparent to x.

Components

Proposition: Components of the containment forest are trees of the following 3 types:

1. (A) The unique main tree rooted at Object.
2. (B) Single-element trees of anonymous classes or modules.
3. (C) Trees rooted at eigenclasses (usually also of cardinality 1).

Note:

• There is some similarity between MRO and includer containment. Both forests consist of a single main tree and zero or more offshoots.
  • In the MRO case, the offshoots are chains corresponding to module-in-module inclusion lists.
  • In the containment case, the offshoots, if any, are usually of minor importance.

Containment ancestors

1. x.cancs is defined iff x is an includer,
2. x.cancs[i] == y iff x.cparent(i) == y.

1. x.croot the containment root of x,   x.croot == x.cancs.last,
2. x.cpathname the (proper) containment path-name of x defined by x.cpathname == (x.cancs - [x.croot]).reverse.map{|y| y.cname}.join("::"), i.e. non-root ancestor names are reversed and joined by "::". Note that for every containment root x (in particular, Object), x.cpathname is an empty string.

Transitions

• A requested container p which is an actual includer.
• A requested containment name n.
• A requested containee q which is an anonymous class or module to be named by n.

• (A) Accepted requests with p being a named class or module.
• (B) Rejected (ignored) requests with p being an anonymous class or module.
• (C) Requests with p being an eigenclass.
  • (C1) Accepted request: class definition in an opened eigenclass.
  • (C2) Rejected (ignored) request: qualified constant assignment does not work for eigenclasses (as of Ruby 1.9).

Object relation summary

S6: Frozenness, taintedness and trust

• .frozen?, .tainted? and .trusted? are boolean attributes of objects.

Transitions

S7: Object cursors

• nestlists is a non-empty finite list of (possibly empty) finite lists of actual includers,
• selfs is a non-empty finite list of actual objects.

• The list nestlists.last.reverse is denoted nesting and called the current nesting.
• The object selfs.last is denoted self and called the current object.
• The object selfs[0] is denoted main and called the main context.

Containment pseudorule

• If nesting[0] exists and is a class or module, then nesting[0].cancs equals nesting.

class A
  class B
    class C
      # current nesting corresponds to A::B::C
    end
  end
end

Transitions

Includer opening/closing

• class X for a class X,
• module M for a module M,
• class << x for an eigenclass x.ec.

Evoked nesting

class X
  class Y; def self.nest1; Module.nesting end end  # def-nesting is [X::Y, X]
  def   Y          .nest2; Module.nesting end      # def-nesting is [X]
end
class A
  p Module.nesting    # [A]
  p X::Y.nest1        # [X::Y, X]
  p X::Y.nest2        # [X]
end

S8: Object data-representatives

• Ω is a finite set of object data-representatives, which we also call ω-objects. Ω is disjoint from O.
• ω() is a partial injective map from O × O onto Ω.
• OID is an object-identifier domain, a subset of integers.
• .oid is an injective map from Ω to OID.
• IVN is a finite set of internal value names, a subset of the value domain Φ.
• .invals is a function from non-includers to the set IVN ↷ Φ of partial maps from internal value names to the value domain Φ.

Iclasses

Condition (S8~1) says that Ω is a copy of all actual MRO domain pairs extended by all pairs (x,x) with x being a pure instance (non-includer). Equivalently, Ω is a copy of the set of all actual objects extended by the set of iclasses.

This is illustrated by the following diagram.

Induced maps

• ω(x,y).module ≝ ω(x,x) whenever ω(x,y) is an iclass.
• ω(x,y).super ≝ ω((x,y).super) whenever (x,y).super (the MRO parent of (x,y)) is defined.
• ω(x,x).func ≝ ω(x.func, x.func) whenever .func is a (partial) function on O and x.func is defined.
• ω(x,x).func ≝ x.func whenever .func is a (partial) function from O to Φ and x.func is defined.

Data fields

Notes:

1. Underline in oid indicates a primary key.
2. There is no equivalent of cparent in Ruby's implementation.
3. The quotation marks in string indicate that the domain of of cnames should be more precisely described as φvalues of Symbols.

The type field indicates the basic type with the following enumeration domain (we assume that ENUM_T is a subset of Φ):

The ωobjects data table

Proposition: The ωobjects data table uniquely determines the S6 structure, up to isomorphism and except for the .φvalue function.

Class nomenclature summary

D0: Estrings

• Encoding is a class, a direct descendant of Object.
• ℇ denotes the set of Encodings, called just encodings.
• ℇ¢ is a subset of ℇ, containing encodings with proper character handling support.
• ℇ$ is a subset of ℇ¢, containing ascii-compatible encodings.
• .name is an injective function from Encodings to ascii bytestrings. (Even .name.upcase is injective.)
• e8b is a distinguished ascii-compatible encoding, called binary and named 'ASCII-8BIT'.
• e7b is a distinguished ascii-compatible encoding, called ascii and named 'US-ASCII'.
• ⅀ denotes the set ℬ × ℇ – the set of pairs (s,e) where s is a bytestring and e an encoding. Elemens of ⅀ are called estrings, meaning encoded strings.
• ⅀⋄ is a subset of ⅀, containing valid estrings.
• ≘ is an equivalence relation on the set ⅀⋄ of valid estrings.

The structure is subject to the following axioms:

(∗) For a valid estring x = (s,e) with non-empty bytestring s and encoding e from ℇ¢, we denote x.chr the leading character of x defined as the unique valid atomic prefix of x, i.e. it is a valid estring (u,e) such that

• u is non-empty,
• u + v = s for some bytestring v,
• u is the smallest bytestring satisfying the previous condition.

• ⅀¢ the set of all valid estrings with encoding from ℇ¢. We call such estrings char-decomposable.
• ⅀e the set of all valid estrings with encoding e.

The .encode() map

• (s,e).encode(f) == (t,f) iff there is a bytestring t such that (s,e) ≘ (t,f).

Proposition:

• For every valid estring (s,e) and every encoding f,
  • (s,e).encode(f).encode(e) == (s,e)
  whenever (s,e).encode(f) is defined.

Ascii and ascii-only estrings

• ascii-only if x.encode(e7b) is defined,
• ascii if they have the e7b encoding, equivalenty x == x.encode(e7b).

Strict concatenation and character decomposition

• (s,e) ∔ (t,f) == (s + t, e) if e == f,
• (s,e) ∔ (t,f) is undefined, otherwise.

• (s,e).chars == [] if s is empty, else
• (s,e).chars == [(u,e)] + (v,e).chars where u, v are the unique bytestrings such that u + v == s and u is the smallest non-empty such that (u,e) is valid ((u,e) is the leading character of (s,e)).

• the length s.length is the length of s.chars,
• s[i] denotes the i-th member of s.chars.

Proposition:

1. The structure (⅀e, ∔, ('',e)) is a free monoid for every encoding e from ℇ¢.
2. s == s[0] ∔ s[1] ∔ ⋯ ∔ s[n-1] for every char-decomposable estring s of length n.
3. For every encodings e, f from ℇ¢,
   • .encode(f) is an isomorphism between (⅀e, ∔, ('',e)) and (⅀f, ∔, ('',f)).
   In particular,
   • .encode(f) and .chars commute,
   • .encode(f) preserves .length.

Loose concatenation

• x + y == x ∔ y whenever x ∔ y is defined,
• ('',e) + x ≘ x ≘ x + ('',e),
• (s,e) + x ≘ (s,e) ∔ x.encode(e) whenever x is ascii-only, similarly
• x + (s,e) ≘ x.encode(e) ∔ (s,e) whenever x is ascii-only.

Transitions

D1: Strings

• String is a class, a direct descendant of Object.
• .estr is a function from Strings and Symbols to the set ⅀ of estrings.

Notes:

• (D1~2) does not apply to Strings.

Transitions

Proposition: The following are consequences of the already introduced conditions:

1. .estr is preserved on symbols.
2. .estr is preserved on frozen strings.

D2: Arrays

• Array is a class, a direct descendant of Object.
• ._list is a function from the set of all Arrays to finite lists of objects.

Notes:

1. Recall that a finite list is a function with the domain being an index set of the form 0, …, n-1 for some natural n.
2. By the introduced terminology, arrays can be considered as maps to lists, but not lists themselves. For instance, there is only one empty list, but possibly many non-identical empty arrays.

• a.length denotes the cardinality of (the domain of) a._list.
• a[i] is defined as follows:

  a[i] == a._list(i)	if 0 ≤ i < a.length,
  a[i] == a._list(a.length - i)	if -a.length ≤ i < 0,
  a[i] == nil	otherwise.

Transitions

D3: Hashes

• Hash and Proc are classes, direct descendants of Object.

• x.hcodes is a finite list of integers called hash codes.
• x.keys   is a finite list of objects called keys.
• x.values is a finite list of objects called values.
• These 3 lists are of equal length.
• x.compare_by_identity? is a boolean attribute.
• x.dflt is an object determining the default value.
• x.dflt_call? is a boolean attribute determining whether x.dflt is interpreted indirectly – as the default's value evaluator, or if it is interpreted directly as the default value itself.

1. (A) The single-list form.
   The hash is a list of triples of the form (hash-code, key, value). The triples have unique (hash-code, key) pairs. If x.compare_by_identity? is true then even keys are unique.
2. (B) The slot form.
   The hash is a map from hash-codes (slots) to lists of triples of the form (idx, key, value) such that
   • idxs are unique not only within slot-lists but within the whole hash,
   • slot-lists respect the idx order (so that ordering in individual slots is induced),
   • keys are unique within slot-lists and if x.compare_by_identity? is true then even within the whole hash.

Example: The following diagrams show a hash x in the two above described forms. Note that due to multiple occurrence of the 'a' key, x.compare_by_identity? is necessarily false.

Transitions

Hash resolution

• .hash is a function from objects to integers (x.hash is called the hash code of x).
• .eql?() is a boolean-valued function on O × O encoding equality between objects.
• .call() is an object-valued function on Procs × Hashes × O.

1. (A) x.compare_by_identity? is false and i is the smallest index such that
   1. k.hash == x.hcodes[i] and either k == x.keys[i] or k.eql?(x.keys[i]),
   or
2. (B) x.compare_by_identity? is true and i is the unique index such that
   1. k == x.keys[i].

1. (1) x[k] == x.values[i] if i is the resolution key-index of k in x, else, if there is no such i,
2. (2) x[k] == x.dflt if x.dflt_call? is false, else
3. (3) x[k] == x.dflt.call(x,k).

D4: Numbers

• Float, Rational and Complex are classes, direct descendants of Numeric.
• Bignum is a direct descendant of Integer. Bignums are called bignums.
• .real and .imag are functions from Complexes to Numerics that are not Complexes.

Note: The Fixnum < Integer < Numeric class chain has already been introduced, see Immediate values.

The structure is subject to the following axioms:

Transitions

D5: Ranges

• Range is a direct descendant of Object. Ranges are called ranges.
• .start and .end are functions from Ranges to objects.
• .exclude_end? is a boolean attribute of Ranges.

Transitions

Object internal value data

Notes:

1. Gray color of a field name indicates that field value is derived.
2. Array or hash lists are not considered to be part of invals data.

A0: Lexical identifiers

• .idcat is a partial function on estrings.

We will also use the word name for non-method identifiers and apply the categorization directly to symbols, so that e.g. for a symbol s, s.estr.idcat == 'constant-identifier' means s is a constant name.

A1: Methods

• Π is a set of anonymous methods, disjoint from the set O of objects,
• π is a distinguished element of Π, called the/a whiteout method, or simply whiteout (the term adopted from []),
• .met() is is a partial function from O × Υ to Π, called own method map,
• μ is a symbol such that μ.estr == "method_missing".

• x.met(s) is a whiteout, then we say that x has own wo-method s or that x is a wo-method-owner of s,
• x.met(s) is not a whiteout, then we say that x has own nwo-method s or that x is an nwo-method-owner of s.

An A1 structure has the following axioms:

If in initial state, an A1 structure satisfies the following:

Notes:

1. No restriction applies to a symbol s to become a method name. In particular, if x.met(s) is defined then it is not required that s.estr.idcat == 'method-identifier', see notes to Transitions.
2. As of MRI 1.9, the following condition is also satisfied:

   (A1~4*)	Eigenclasses x.ec of Numerics x cannot have own methods.

Method owner

Propositions:

1. x.mowner(s) == x  iff  x is an nwo-method-owner of s.
2. x.mowner(s,wo).mowner(s,wo) == x.mowner(s,wo) whenever x.mowner(s,wo) is defined.

Method inheritor

By an inherited method map we mean the partial function .met_h() from O × Υ × {true, false} to Π defined by

Simplified method resolution

1. (1) smr(x,s) == (x.ec.mowner(s), s) if x.ec.mowner(s) is defined, else
2. (2) smr(x,s) == (x.ec.mowner(μ), μ) if x.ec.mowner(μ) is defined, else
3. (3) smr(x,s) is undefined.

Notes:

• The expression x.ec.mowner(s) expresses the Ruby method call mantra []:

  One to the right, then up.

  This is applied in both search phases, (1) and (2).
• By convention, each eigenclass is an nwo-method inheritor of μ, so that (3) never occurs.

Interchangeability of .ec and .aclass

Proposition: For every object x and every symbol s,

• x.ec.mowner(s) == x.aclass.mowner(s) (either both sides are undefined or both defined and equal).

Transitions

Notes:

1. If x is not specified in the rightmost column, then it is assumed that x equals self unless self == main – in this case x == Object.
2. As of Ruby 1.9, direct transitions for removing a whiteout method are not supported.
3. In (a) cases, the restriction s.estr.idcat == 'method-identifier' applies to the method name s (or to the alias a). In (b) cases, no such restriction applies, as shown in the following example.

   class X
     define_method ("")      { self }
     define_method ("1 + 1") { 3 }
     alias_method  "@a", ""
   end
   p X.new.send("").send("@a").send("1 + 1")  #-> 3
   p X.instance_methods(false)                #-> [:"", :"1 + 1", :@a]
   class X
     undef_method  "1 + 1"
     remove_method "", "@a"
   end
   p X.instance_methods (false)               #-> []
   

A2: Properties

• .pty() is a partial function from O × Υ to O, called property map,
• κ is a symbol such that κ.estr == "const_missing".

We categorize properties according to .idcat:

Notes:

• Gray color in the last row indicates that local variables are not properties in the above sense. They cannot be explained without introducing additional concepts, in particular, blocks, so that they appear to be beyond the scope of a document titled Ruby object model.

An A2 structure has the following axioms:

Note: Global variable ownership is a rather artificial concept. We have chosen the Kernel as the owner, because it owns the global_variables method for global variable enumeration.

If in initial state, an A2 structure satisfies the following:

Class variables

Note: Class variables are considered a controversial Ruby feature.

Constant owner

Propositions:

1. x.cowner(s) == x  iff  x is a constant-owner of s.
2. x.cowner(s).cowner(s) == x.cowner(s) whenever x.cowner(s) is defined.

Constant inheritor

By an inherited constant map we mean the partial function .cst_h() from O × Υ to O defined by

Property owner and inheritor

• .powner() is a partial map from O × Υ to O defined by

  (1) x.powner(s) == x.cowner(s)	if s is a constant name and x.cowner(s) is defined,
  (2) x.powner(s) == x	if s is an instance variable name and x.pty(s) is defined,
  (3) (value not specified)	if s is a class variable name and (condition not specified),
  (4) x.powner(s) == Kernel	if s is a global variable name and Kernel.pty(s) is defined,
  (5) x.powner(s) is undefined otherwise.

• .pty_h() is a partial map from O × Υ to O defined by
  • x.pty_h(s) == x.powner(s).pty(s) whenever x.powner(s) is defined.

Notes:

1. .pty_h() is only related to inheritance in cases (1) and (3).
2. We assume that .pty_h() factors through .powner() even for class variables.

Qualified constant resolution

1. (0) qcr(x,s) is undefined if x is not an includer or s is not a constant name, else
2. (1) qcr(x,s) == (x.cowner(s), s) if x.cowner(s) is defined, else
3. (2) qcr(x,s) == (x.ec.mowner(κ), κ) if x.ec.mowner(κ) is defined, else
4. (3) qcr(x,s) is undefined.

Notes:

• If qcr(x,s) == (y,t) is defined in phase (1), then y.pty(t) equals the evaluation x::<s.estr> (for example, if s.estr == "A", then y.pty(t) equals x::A).
• If qcr(x,s) == (y,κ) is defined in (2), then the method y.met(κ) gets called with x as the receiver and s as the argument.
• By convention, each includer is an nwo-method inheritor of κ, so that phase (3) never occurs.
• Constants owned by the Object class are considered toplevel constants not designed for referencing by descendants. If qcr(x,s) == (Object,s) and x != Object then (in non-nil $VERBOSE mode) a warning is issued.
• For a symbol s the expression ::<s.estr> is equivalent to x::<s.estr> with x being equal to Object.

The qcr map can be expressed as a method of Module as follows:

class String
  def constant_name?; !!match(/^[A-Z]\w*$/) end
end
class Module
  def cowner(s)
    ancs.find{|x| x.const_defined?(s, false)}
  end
  def qcr(s)
    !s.to_s.constant_name?                ? nil :
    (o = cowner(s))                       ? [o, s.to_sym] :
    respond_to?(t = :const_missing, true) ? [method(t).owner, t] : nil
  end
end

Unqualified constant resolution

• x == nesting[0] if the nesting cursor nesting is nonempty, else
• x == main.ec otherwise, i.e. if the current nesting is empty.

• q == nesting + x.ancs + Object.ancs if x is a module,
• q == nesting + x.ancs otherwise, i.e. if the start point is a class or an eigenclass.

1. (0) uqcr(s) is undefined if s is not a constant name, else
2. (1) uqcr(s) == (w, s) if w is the least-indexed member of q such that w.pty(s) is defined, else, if no such w exists,
3. (2) uqcr(s) == (x.ec.mowner(κ), κ) if x.ec.mowner(κ) is defined, else
4. (3) uqcr(s) is undefined.

Notes:

• uqcr(s) corresponds to the evaluation of <s.estr> – i.e. there is no double-colon (::) before <s.estr>.
• We can assume the uniq operation (removing duplicate members) to be applied to the lookup sequence q.
• If nesting == [r] then constants owned by the Object class are not visible via the unqualified constant resolution – they must be referenced using the :: prefix. Example (using another class that is not a descendant of Object):

  class A < BasicObject
    def self.const_missing(s); :missing end
    p   [Module, ::Module]  # [:missing, Module]
  end
  

The uqcr map can be expressed as a method of Array as follows:

$main = self
class Array
  def uqcr(s)
    return nil if !s.to_s.constant_name?
    x = first || $main.ec
    q = self + x.ancs + (::Class === x ? [] : ::Object.ancs)
    o = q.find{|y| y.const_defined?(s, false)}
    o                                       ? [o, s.to_sym] :
    x.respond_to?(t = :const_missing, true) ? [x.method(t).owner, t] : nil
  end
end

Note: The method must be called with the current nesting as the receiver, i.e. Module.nesting.uqcr(s).

Immediate values revisited

• be frozen/non-frozen (by contrast, they cannot be tainted or untrusted),
• have instance variables.

class Fixnum
  def false(i = 1)
    @n_falsified ||= 0
    @n_falsified += i
    self
  end
  def report
    "#{self} falsified #{@n_falsified || 0} times"
  end
end
puts 5.report        # 5 falsified 0 times
puts 6.report        # 6 falsified 0 times
puts 5.false.report  # 5 falsified 1 times
puts 5.false.report  # 5 falsified 2 times
puts 6.false.report  # 6 falsified 1 times

Transitions

Notes:

1. If x is not specified in the rightmost column, then
   1. x equals the artificial owner Kernel if s is a global variable name, else
   2. x equals Object if self == main, else
   3. x equals self.
2. Gray color indicates that for class variables, the owner is not exactly specified in this document.

Containment revisited

1. A::B::C, if x.croot equals Object,
2. #<Class:0xaafc40>::A::B::C, otherwise (i.e. if x.croot is an eigenclass).

Note: (∗) x.name may be even undefined, as shown in the following section.

Encoding compatibility

X = Object.const_set("X\u00e1".encode('utf-8'), Class.new)
class X
  Y = const_set("Y\u00e1".encode('iso-8859-2'), Class.new)
end
p X::Y.name    # raises Encoding::CompatibilityError

Sibling consistency

class X
  class Y; end
  Z = Y
  class_eval { remove_const :Y }
  class Y; end
end
x = X
y = X::Y
z = X::Z
puts "#{y.object_id}-->#{y}"
puts "#{z.object_id}-->#{z}"

1. y.cparent == z.cparent == x, and
2. y.cname == z.cname == "Y".

class Module
  alias toS to_s
  alias __remove_const remove_const; private :__remove_const
  def remove_const(sym)
    c = const_defined?(sym, false) ? const_get(sym,false) : nil
    if c.kind_of?(Module) && c.toS.match(Regexp.new("((\\:\\:)|(^))#{sym}$"))
      raise NameError.new(
           "Cannot remove module/class :#{sym} from #{toS}", sym)
    end
    __remove_const(sym)
  end
end

Property consistency

1. (a) removing a constant (see Sibling consistency),
2. (b) reassignment of a constant.

Resolution consistency

class X
  def a; @a end
  def initialize; @a = self.class::A.new end
  class A
    def report; self.to_s end
  end
end
class Y < X
  def initialize; super end
  class A < A; end
end
puts X.new.a.report  #--> #<X::A:0xab80d0>
puts Y.new.a.report  #--> #<Y::A:0xab8028>

A3: Method visibility

• .mvisibility() is a partial function from O × Υ to the set {:private, :protected, :public}.

The following axioms are required to hold:

We define inherited visibility .mvisibility_h() by

• x.mvisibility_h(x) == x.mowner(s).mvisibility(s)

Unqualified method resolution

• uqmr(s) == smr(self, s) whenever the right side is defined.

The uqmr map can be expressed as a method of Object as follows:

class Object
  def uqmr(s)
    t = :method_missing
    respond_to?(s, true) ? [method(s).owner, s] :
    respond_to?(t, true) ? [method(t).owner, t] : nil
  end
end

Qualified method resolution

1. (1) qmr(x,s) == (x.ec.mowner(s), s) if
   1. (a) x.ec.mvisibility_h(s) is :public, or
   2. (b) x.ec.mvisibility_h(s) is :protected and self.ec ≤ x.ec.mowner(s), else
2. (2) qmr(x,s) == (x.ec.mowner(μ), μ) if x.ec.mowner(μ) is defined, else
3. (3) qmr(x,s) is undefined.

Notes:

• (2) is applied iff
  • x.ec.mvisibility_h(s) is :private or
  • x.ec.mvisibility_h(s) is undefined, i.e. x.ec.mowner(s) is undefined.
• x.ec.mvisibility_h(μ) is irrelevant.

The qmr map can be expressed as a method of Object as follows:

class Object
  def qmr(x,s)
    if x.respond_to?(s, false)   # public or protected
      o = x.method(s).owner
      if o.protected_instance_methods(false).include?(s) && !kind_of?(o)
         o = nil
      end
      if o then return [o, s] end
    end
    t = :method_missing
    x.respond_to?(t, true) ? [x.method(t).owner, t] : nil
  end
end

Transitions

class X; def m; end
end
p X.private_instance_methods(false) # []

X.freeze

class X; private :m
end
p X.private_instance_methods(false) # [:m]

Notes:

1. If x is not specified in the rightmost column, then x equals self unless self == main – in this case x == Object.
2. v is implied by the method (visibility specifier) used.

Disowned visibility

class X; end
class << X
  private; def m; end
end
ec = (x = X.new).singleton_class

p ec.respond_to?(:m)                                 # false
  ec.public_class_method(:m)
p ec.respond_to?(:m)                                 # true
p ec.method(:m).owner                                # X.ec (#<Class:X>)

p ec.singleton_methods(false)                        # [:m]
p ec.singleton_class.public_instance_methods(false)  # []
p ec.singleton_methods(false)                        # []

A4: Arrows

• Α is a set of arrow data-representatives or just arrows, disjoint from hitherto introduced sets,
• ϙ(), …, βɦ() are injective maps to arrows with mutually disjoint ranges denoted Αϙ, …, Αβɦ.

Internal arrows

• (A) internal property arrows,
• (B) inclusion lists arrows,

Internal property arrows

Note: (*) This corresponds to the identity function .self on O. Because of the dot-notation, there is no naming conflict with the already introduced self cursor.

Induced maps

• ϙ-arrows and ϻ-arrows:
  Object internal properties and module inclusion lists are represented by the following functions on ϙ-arrows and ϻ-arrows:

  Keys
  ϙ(x,s).source ≝ x ϙ(x,s).name ≝ s	ϻ(x,i).source ≝ x ϻ(x,i).idx ≝ i
  Values
  ϙ(x,s).target ≝ x.s	ϻ(x,i).target ≝ x.incs[i]

• ι-arrows and ϰ-arrows:
  Array and hash members are represented by the following functions on ι-arrows and ϰ-arrows:

  Keys
  ι(x,i).source ≝ x ι(x,i).idx ≝ i	ϰ(x,i).source ≝ x ϰ(x,i).idx ≝ i ϰ(x,i).hcode ≝ x.hcodes[i] ϰ(x,i).key ≝ x.keys[i]
  Values
  ι(x,i).target ≝ x._list[i]	ϰ(x,i).target ≝ x.values[i]

• α-arrows and β-arrows:
  Method and property maps are represented by the following functions on α-arrows and β-arrows:

  Keys
  α(x,s).source ≝ x α(x,s).name ≝ s	β(x,s).source ≝ x β(x,s).name ≝ s
  Values
  α(x,s).target ≝ x.met(s)	β(x,s).target ≝ x.pty(s)
  Attributes
  α(x,s).mvisibility ≝ x.mvisibility(s)

Own data fields

Preview arrows

Object data stratification

A5: Object copy

• .dyn_class? is a boolean attribute of classes indicating whether the class is dynamic.

• .clontype is an attribute of objects with possible values 'clone' or 'none'.
• .dumptype is an attribute of objects with possible values 'clone', 'ref' or 'none'.