[ruby-talk:00539] A new discussion topic ;-)

Hi all,

and here I am again with a new discussion topic. :-)

What I mention here is not meant as real improvment proposal. I want
only know, what you others think about it?

Some time ago, I have seen another language called Self. I found the
concepts very powerful. Unfortunately there are no implementations
available except for Solaris.

Self is a OOL, but *without* the normal class concept. I will tell you
more using Ruby as example.

I want to ask you all, what do you think, if there would be a language
with a syntax like Ruby, but the OO features of Self (okay, not all
but some of it). So here we go:

In that language it would not be necessary to have classes! We would
only have objects. A object would be build like that:

    object Foo
        def say_hello(name)
            print "#{@greeting} #{name}\n"
        end
    
        def say_greeting(greeting, name)
            print "#{greeting} #{name}\n"
        end 
    end

We could use that object at once, without instantiation, as it is an
object not a class.

    Foo.say_greeting("Hello", "world")

Okay, using `Foo#say_hello' would not make any sense, as the variable
`@greeting' is not initialized meaningfully. :-) As that object did
not inherit from anywhere, it could be seen as module.

But we also could *real* OOP with that concept! For example I could
create an object `bar', that inherits from the object `Foo'. I would
have to write:

    object bar
        ^parent = Foo
        ^super = Cloneable
    
        @greeting = "Hello"
    
        def initialize(greeting)
            @greeting = greeting
        end
    
        def say_greeting(name)
            ^parent.say_greeting(@greeting, name)
        end
    end
    
As you see, I would put the `Foo' object in a object variable
`^parent'! The name is unimportant. I would also be able to call it
`^foo'. The important thing is the `^' prefix. All names with begins
with a `^' would point to a superclass. We even could change the
content of such a variable during runtime, so that we would get
dynamic inheritance.

But that alone would not be enough. `bar' would inherit from `Foo',
but it would, like `Foo', not to be able to create new instances from
itself! So I have also to let `bar' inherit from object `Cloneable'.

Here I have written `bar' in small caps. That language would allow to
reassign a new object definition to `bar' but not to `Foo'. Like in
Ruby, identifiers beginning with upper caps, denote constants.

I could use the object `bar' directly like `Foo'.

    bar.initialize("Hallo")
    bar.say_hello("matz")
    bar.say_greeting("matz")   # would be the same as `say_hello'

But I could now create an new instance of it:

    bar2 = bar.clone("Konichi wa")
    bar2.say_hello("gotoken")

There would not be any difference between `Foo' and `bar'. Both are
objects. Only `Foo' doesn't inherit from anywhere, but `bar' does!

As you can see, there would be a resend message syntax.
`^parent.<method>' would be a directed resend. The message would be
searched in the hierarchy beginning with the `^parent' slot. However,
^<method> would be an undirected resend. The message would be searched
in all parents of that object.

What do you think?

I think the Self approach is a great idea. There are no classes
anymore. Only objects.  Every object could be used to build
instances. Objects without inheriting from others, could be seen as
Ruby `Modules'. Objects, inheriting from `Cloneable' could be used
directly, but could also build new instances like a class in Ruby.

As I have already said, it is not a real proposal. But I would like to
know, what would you think about a language with Ruby's syntax but a
OOP concept like the explained above. Would you like such a language?

Waiting for opinions,  :-)
Cle.