[ruby-talk:16880] RE: Something strange with Ruby's inheritance mechanism

# -----Original Message-----
# From: Mathieu Bouchard [mailto:[e-mail]] 
# Sent: 26 ???? 2001 ?. 12:14
# To: Aleksei Guzev
# Cc: ruby-talk ML
# Subject: Re: [ruby-talk:16873] RE: Something strange with 
# Ruby's inheritance mechanism
# 
# 
# On Tue, 26 Jun 2001, Aleksei Guzev wrote:
# > Every strong-typed language implies a lot of text being not a code, 
# > but declarations.
# 
# Have you seen type-inference? Some languages actually analyze 
# your code for types and "templatize" your code according to 
# what you *don't* write. 
# You type code in the listener, and it answers with the 
# "declarations", which you don't have to put anywhere in your 
# files, as they are generated by compilation of the code.

That's a good thing.

# 
# > Ruby should provide a short-time development and therefore
# > no type-checking.
# 
# Short-time development should mean no type-checking when it 
# makes development shorter, and type-checking when it makes 
# development shorter. There's a balance you have to get.
# 
# > Generally, classes are equal when they provide equal 
# interfaces. Class 
# > B is a subclass of A when it provides all the methods of A and some 
# > methods in addition. "<" in Ruby is a shorthand allowing 
# programmer to 
# > shorten the code.
# 

Strong typing shortens development of large project involving large
stuff. I use Ruby only to call huge complicated application written in
strong-typed languages.

Type checking is made at run-time ( as everything an script ). Class of
object is determined by its interface. If the object implements
particular interface then it belongs to the corresponding class. Take a
look at Enumerable module documentaion.

"The class must provide a method each, which yields successive members
of the collection".

Thus providing method 'each' one will get Enumerable mix-in working.
Moreover defining for class A methods similar to methods of module
Enumerable will allow use instances of A at every place where an
Enumerable instance is allowed.

The disadvantage of strong typing is vivid in MS MFC library. If one
wishes instances of its  class CA be collected in a linked list, he
needs derive CA from Cobject, but this implies defining of hash function
for CA!
Thus one has to write a hash function in order to add object to a linked
list. And there are much more overhead.

# In Ruby, A == B means it's _the_ same class, and A < B means 
# all objects that inherit from A also inherit from B, that is, 
# the set of A objects is smaller than the set of B objects. 
# Ruby provides "class A<B" as a notation consistent with Class#<.
# 
# Two classes A,B such that A<B could have an equal number of 
# methods. They could also have equal interfaces (but the Ruby 
# interpreter couldn't tell)

I didn't say about Ruby but I said "generally"

# 
# matju
#