Object-oriented programming is all about objects. About objects and messages they pass to each other.
Programs contain many objects. Way too many to make each of them by hand. Objects need to be mass-produced. There are basically two ways of mass producing objects.
- The industrial way - building factory objects that build other objects.
- The biological way - building prototype objects that can be cloned.
a_factory = Class.new()
a_factory.define_instance_method(:hello) {|arg|
puts "Hello, #{arg}!"
}an_object = a_factory.new()
an_object.hello("world")a_prototype = Object.new()
a_prototype.define_method(:hello) {|arg|
puts "Hello, #{arg}!"
}an_object = a_prototype.clone()
an_object.hello("world")Array is a prototype for all arrays and so on.
Industrial way is more organized, but much more complex and heavy. There are objects, classes, class objects, superclasses, inheritance, mixins, metaclasses, singleton classes. It's just too complex.
This complexity exists for a reason, but sometimes we'd really rather get away with it and use something simpler.Prototype-based programming in Ruby
And in Ruby we can ! First, we need to be able to define methods just for individual objects:def x.hello(arg)
puts "Hello, #{arg}!"
end
x.hello("world") # => "Hello, world!"
y = x.clone()
y.hello("world") # => "Hello, world!"z = x.clone()
def x.hello(arg)
puts "Guten Tag, #{arg}!"
end
def z.hello(arg)
puts "Goodbye, #{arg}!"
end
x.hello("world") # => "Guten Tag, world!"
y.hello("world") # => "Hello, world!"
z.hello("world") # => "Goodbye, world!"class Class
def prototype
@prototype = new unless @prototype
return @prototype
end
def clone
prototype.clone
end
end
def (String.prototype).hello
puts "Hello, #{self}!"
end
a_string = String.clone
a_string[0..-1] = "world"
a_string.hello #=> "Hello, world!"Horizontal gene transfer
Of course transfer of genes from parents to offspring is only half of the story. The other half is gene transfer between unrelated organisms. We can easily use delegation andmethod_missing, but let's do something more fun instead - directly copying genes (methods) between objects.
a_person = Object.new
class <<a_person
attr_accessor :first_name
attr_accessor :name
def to_s
"#{first_name} #{name}"
end
end
nancy_cartwright = a_person.clone
nancy_cartwright.first_name = "Nancy"
nancy_cartwright.name = "Cartwright"
hayashibara_megumi = a_person.clone
hayashibara_megumi.first_name = "Megumi"
hayashibara_megumi.name = "Hayashibara"to_s method:
def hayashibara_megumi.to_s
"#{name} #{first_name}"
endto_s:
inoue_kikuko = a_person.clone
inoue_kikuko.first_name = "Kikuko"
inoue_kikuko.name = "Inoue"japanese_to_s = hayashibara_megumi.copy_gene(:to_s)
inoue_kikuko.use_gene japanese_to_sdefine_method is private (should be public), and
there is no simple singleton_class.
Both will hopefully be fixed in Ruby 2.
class Object
def singleton_class
(class <<self; self; end)
end
end
class Class
public :define_method
endclass Object
def copy_gene(method_name)
[method(method_name).unbind, method_name]
end
def use_gene(gene, new_method_name = nil)
singleton_class.define_method(new_method_name||gene[1], gene[0])
end
endputs nancy_cartwright #=> Nancy Cartwright
puts hayashibara_megumi #=> Hayashibara Megumi
puts inoue_kikuko #=> in `to_s':TypeError: singleton method called for a different objectputs inoue_kikuko #=> in `define_method': can't bind singleton method to a different class (TypeError)UnboundMethod class represents methods not bound to any objects. It contains internal field rklass, and it can only bind to objects of such class (or subclasses). First, let's define a method to change this rklass:
class UnboundMethod
def rklass=(c)
RubyInternal.critical {
i = RubyInternal::DMethod.new(internal.data)
i.rklass = c.object_id * 2
}
end
endclass Object
def copy_gene(method_name)
[method(method_name).unbind, method_name, internal_type]
end
def use_gene(gene, new_method_name = nil)
raise TypeError, "can't bind method to an object of different internal type" if internal_type != gene[2]
gene[0].rklass = self.class
singleton_class.define_method(new_method_name||gene[1], gene[0])
end
endputs nancy_cartwright #=> Nancy Cartwright
puts hayashibara_megumi #=> Hayashibara Megumi
puts inoue_kikuko #=> Inoue KikukoFull listing
require 'evil'
class Object
def singleton_class
(class <<self; self; end)
end
end
class UnboundMethod
def rklass=(c)
RubyInternal.critical {
i = RubyInternal::DMethod.new(internal.data)
i.rklass = c.object_id * 2
}
end
end
class Class
public :define_method
end
class Object
def copy_gene(method_name)
[method(method_name).unbind, method_name, internal_type]
end
def use_gene(gene, new_method_name = nil)
raise TypeError, "can't bind method to an object of different internal type" if internal_type != gene[2]
gene[0].rklass = self.class
singleton_class.define_method(new_method_name||gene[1], gene[0])
end
end
a_person = Object.new
class <<a_person
attr_accessor :first_name
attr_accessor :name
def to_s
"#{first_name} #{name}"
end
end
nancy_cartwright = a_person.clone
nancy_cartwright.first_name = "Nancy"
nancy_cartwright.name = "Cartwright"
hayashibara_megumi = a_person.clone
hayashibara_megumi.first_name = "Megumi"
hayashibara_megumi.name = "Hayashibara"
def hayashibara_megumi.to_s
"#{name} #{first_name}"
end
inoue_kikuko = a_person.clone
inoue_kikuko.first_name = "Kikuko"
inoue_kikuko.name = "Inoue"
japanese_to_s = hayashibara_megumi.copy_gene(:to_s)
inoue_kikuko.use_gene japanese_to_s
puts nancy_cartwright
puts hayashibara_megumi
puts inoue_kikuko
