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'.

Object cloning / duplication

Notes:

1. Cloning / duplicating objects x with x.clontype == 'none' is not supported.
2. The inheritance root cannot have siblings, thus r.clontype == 'none'.
3. There seems to be a difference between clone versus dup support for instances of Method and UnboundMethod. This difference is not expressed by the above description.
4. Hash cloning/duplication is based on sequential insertion of hash members. This might result in a modified set of ϰ-arrows.
5. (∗) In addition, for each a from x.arrows that is an own method arrow (an α-arrow) the method a.target is copied too. This allows for proper copy of method de-aliasing. To describe this would require introducing arrows for .orig_owner and .orig_name.

Object dumping

The sets x.objects and x.arrows are then either undefined (in the case of a non-dumpable object x) or they are defined by

• x.objects == x.objects(n) and x.arrows == x.arrows(n)

• x.objects(0) is undefined if x.dumptype == 'none', else
• x.objects(0) is the empty set if x.dumptype == 'ref', else
• x.objects(0) is undefined if x.ec has an own method or property (i.e. an α- or β-arrow a such that a.source == x.ec), else
• x.objects(0) is the single-element set {x}.

• x.arrows(0) is undefined if x.objects(0) is undefined, else
• x.arrows(0) is the the single-element set {ϙ(x,'self')} if x.objects(0) is the empty set, else
• x.arrows(0) is the set of all arrows a such that either (A) or (B) is satisfied:
  • (A) a.source == x and a is of one of the following types:
    • a special-value ϙ-arrow,
    • a ι-arrow (array member),
    • a ϰ-arrow (hash member),
    • a β-arrow (own property, necessarily instance variable, because x is a pure instance (non-includer)),
  • (B) a.source.ce == x and a is one of the following types:
    • a ϙ-arrow named sc (so that a corresponds to a .class-link – recall that x.ec.sc equals x.class for terminal x),
    • a ϻ-arrow, (so that a corresponds to an .ec.incs[i]-link between x and a module included in the eigenclass x.ec).

• x.objects(n) is undefined if
  • x.objects(n-1) is undefined, else if
  • y.objects(0) is undefined for some object y that is the target of an arrow from x.arrows(n-1),
  else
• x.objects(n) is the set of all objects y such that
  • y ∈ x.objects(n-1) or
  • y.dumptype == 'clone' and y is the target of an arrow from x.arrows(n-1).

• x.arrows(n) is undefined if x.objects(n) is undefined, else
• x.arrows(n) is the set of all arrows a such that
  • a ∈ x.arrows(n-1), or
  • a ∈ y.arrows(0) for some y ∈ x.objects(n-1).

Comments:

1. Some arrow paths starting with an .ec-arrow are considered as a single short-cut arrow (case (B)).
2. If x.dumptype == 'ref' then x.objects is defined as empty set but x.arrows is defined as a singleton set containing just the identity arrow of x. This means that just a reference to x is dumped.
3. The set x.objects can only contain pure instances (non-includers). Includers are dumped by reference.
4. Dumping of x is unsupported whenever there is an arrow path ending in an object y with y.objects(0) undefined, in particular, if y.dumptype == 'none'.

A6: Method de-aliasing

• .orig_owner is a function from the set Π ∖ {π} to includers assigning each non-whiteout method its original owner.
• .orig_name is a function from the set Π ∖ {π} to Υ assigning each non-whiteout method its original name.

Notes:

• If (x,s) == (α.orig_owner, α.orig_name) then any of the following cases may occur:
  1. x.met(s) == α (the most typical case),
  2. x.met(s) is undefined or equals π,
  3. x.met(s) is an nwo-method different from α.

Transitions

def def_report
 class_eval { def report; super end }
end
class A; def report; '-A-' end end
class B; def report; '-B-' end end
class X < A; def_report; end
class Y < B; def_report; end
p Y.new.report #-> -B-
p X.new.report #-> NotImplementedError

Note: The example demonstrates that the problem is not restricted to eigenclasses, as suggested by the error message (super from singleton method that is defined to multiple classes is not supported ).

Parent method call (super)

• (A) pmr(x,o,s) is undefined if either o.met(s) is undefined or a whiteout or o does not occur in x.ec.ancs.
• (B) Denote α = o.met(s).
  • (1) Let i be the smallest such that x.ec.ancs[i] == α.orig_owner. If no such i exists then apply (C).
  • (2) Let j be the smallest such that i < j and x.ec.ancs[j] is a method owner of α.orig_name. If no such j exists then apply (C).
  • (3) If x.ec.ancs[j].met(α.orig_name) is a whiteout then apply (C).
  • (4) pmr(x,o,s) = (x, x.ec.ancs[j], α.orig_name).
• (C) pmr(x,o,s) == (x, x.ec.mowner(μ), μ) if x.ec.mowner(μ) is defined, else
• (D) pmr(x,o,s) is undefined.

Notes:

1. (B4) shows that the parent method call involves de-aliasing.
2. Repetitive inclusion lists can induce cycles in the pmr map.

Examples:

• De-aliasing of C#report results in skipping of B#report.

  class O; def report; "O" end end
  class A < O; def report; "A" + super end end
  class B < A; end
  class C < B; alias report report end
  class B; def report; "B" end end
  class A; remove_method :report end
  puts C.new.report #--> AO
  

• Multiple occurence of M in B's ancestor list causes a cycle of supers.

  module M
   def report(i=0); "-M(#{i})" + (i < 4 ? super(i+1) : " ...") end
  end
  class A; end
  class B < A; include M end
  class A; include M end
  p B.ancestors #--> [B, M, A, M, Object, Kernel, BasicObject]
  p B.new.report #--> "-M(0)-M(1)-M(2)-M(3)-M(4) ..."
  

• In this example, A inherits the report method from N. The original method owner of N#report is M. This module does NOT appear among A's ancestors until the re-inclusion of N into A.

  module M; def report; super end end
  module N; end
  class O; def report; '-O-' end end
  class A < O; include N end
  module N; include M end
  module N; alias report report end
  A.new.report rescue puts $!.inspect #--> super: no superclass method
  p A.ancestors.take(4) #--> [A, N, O, Object]
  class A; include N end
  p A.ancestors.take(5) #--> [A, N, M, O, Object]
  puts A.new.report #--> -O-
  

Actuality revisited

• x has own includees,
• x has own methods,
• x has own properties (constants or instance variables).

The .ec_ref hack

class Class
 EC_ID_DELTA = (x = Class.new).singleton_class.object_id - x.object_id
 def ec_ref
 ObjectSpace._id2ref(object_id + EC_ID_DELTA)
 end
end

The _class_method hack

class X; end; class Y < X; end
def X.m; end
 nnt_delta_report
Y.private_class_method(:m)
 nnt_delta_report # 0
ec = Y.singleton_class
 nnt_delta_report # 1
p ec.private_instance_methods(false) # [:m]

Built-in Ruby reflection

Blank slate objects

A test whether an object x is not a blank slate object is performed by Object === x (it evaluates to true if x is an Object, i.e. x is not a blank slate object).

The object-to-integer map .object_id

The inverse to .object_id

• ObjectSpace._id2ref(x) == y if y.object_id == x for some, necessarily unique, object y.
• If there is no such y, then an exception is raised.

Note: The method also works for semiactual objects, see The .ec_ref hack.

The .toX map

• x.toX ≝ "%#08x" % [x.oid2]

Note: The 8 digit which is used in the string format determines string length and is platform dependent.

The conversion between .object_id and .oid2 is partially described in the following table.

The object-to-string map .toS

In contrast to object_id, the to_s method is – by convention – subject to override. We therefore refer to an alias method .toS which can be established by

class Object; alias toS to_s end
class Module; alias toS to_s end

1. Is x a named module?
2. The includer containment component type (A, B, or C) of x or of x.class if x is a non-includer.
3. Is x terminal?

Observations: Denote y = x.ec(i).

1. Denote n the number of trailing '>' characters of y.toS. Then for the eigenclass index i the following holds:
   • i == n - 1 if y.toS contains the string ":0x" not followed by a string containing "::",
   • i == n otherwise.
2. For i > 0, the substring of y.toS delimited by the last occurrence of a single ':' and the first occurrence of trailing '>' equals
   • x.toS if x is a named class or module with x.croot equal to Object,
   • x.croot.toX + ">::" + x.cpathname if x is a named class or module with x.croot an eigenclass,
   • x.toX otherwise.
3. Whether y is terminative cannot be detected from y.toS alone (X.ec::A.toS and X.ec::N.toS have same format).

class Object
 def eci
 (s = toS).length - s.index(/[>]*$/) - (s.match(/:0x(?!.*\:\:)/)? 1:0)
 end
 def pr_chunk
 (m = toS.match(/[^:]\:(?!\:)(?!.*[^:]\:[^:])(.*[^>])[>]+$/)) ? m[1] : toS
 end
 def pr
 if eci == 0 then return self end
 c = pr_chunk
 if c.include?(">") # the complicated case: pr.croot is an eigenclass
 r = (m = c.match(/^(0x.*)[>]::(.*)$/)) ? m[1] : raise("???")
 r = ObjectSpace._id2ref(eval(r)/2)
 return r.class_eval("self::" + m[2])
 end
 (p = ::Object.class_eval(c)).instance_of?(Fixnum) ?
 ObjectSpace._id2ref(p/2) : p
 end
end

Containment reflection

class Module
 def cname
 (m = toS.match(/(^|(::))([^:>]+)$/)) ? m[3] : nil
 end
 def cpathname
 (m = toS.match(/(^Object|^|(::))([^<>]*)$/)) ? m[3] : ""
 end
 def croot_toS
 ((s = toS).match(/^[^>]*$/)) ? "Object" :
 (m = s.match(/(.*?)::.*[^>]$/)) ? m[1] : toS
 end
 def croot
 if eci > 0 then return self end
 n = croot_toS
 m = n.match(/\:(0x[^>]*)/)
 m ? ObjectSpace._id2ref(eval(m[1])/2) : eval("::" + n)
 end
 def cancs
 a = [croot]
 cpathname.split("::").each { |x| a << a.last.const_get(x, false) }
 a.reverse!
 end
 def cparent(i = 1); cancs[i] end
end

Enumerating objects

Note: (∗) Fixnums can be enumerated by domain enumeration. The not supported status means that there is no efficient built-in way (known to the author) of enumerating just the fixnums with non-default state (see Immediate values revisited).

Reference to built-in Ruby reflection