Hacker Newsnew | past | comments | ask | show | jobs | submitlogin

One thing one could do is thinking of

    object.foo.bar
similar as

    1+2+3
The later would be

     (+ 1 2 3)
in Lisp.

Thus slot access could be written as:

     (? object foo bar)
All we need would be a macro ?, which is easy.

Alternatively we can write a reader macro such that we can write:

    #?object.foo.bar
The problem with short names and possible package prefixes remains:

    (? w1 ws:panes ws:background-color color:name)
vs.

    #?w1.ws:panes.ws:background-color.color:name
vs.

    (color:name (ws:back-ground-color (ws:panes w1)))


See my other comment; keywords allow for short names and there is no concern about GF collisions if methods are namespaced to the class anyways.


Yes, there is a concern about collisions when methods are namespaced to classes using non-packaged identifiers.

Collisions occur under inheritance. Example: you would like to add a member foo to a base class. The class is widely derived in lots of code, not all of which you even have access to, which might be injecting its own foo. C++ partially deals with this with hacks, like derived identifiers shadowing base class ones (which is totally non-OOP and breaks for virtual functions, which cannot be non-OOP by their nature). C++ partialy deals with the virtual function issue by treating the type signature as part of the name, so that foo(int) and foo(widget&) are different virtuals.

Collisions could be a problem even if there is just one class, but its contents are controlled by several parties. Every group has to watch out that they aren't reusing any other group's symbols in that class.

Any sort of automatic mechanism which can inject symbols into a class (e.g. in support of aspect-oriented programming or whatever) will run into a clash, unless it uses gensyms, which is inconvenient if the intent is to inject names that are to be publicly known and referenced.




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: