How do Smalltalk disambiguate messages?

I was actually curious about this in Ruby as well, since Ruby also doesn't
have the Smalltalk message syntax.

I figure that the magic behind it is that Smalltalk takes strings like "dict
at: 'foo' put: 'bar'" and evaluates them into a JavaScript equivalent of
"dict['at:put:']('foo', 'bar')".

Basically, my proof of concept(I cheated with regex to cut time):

'use strict';

var Dictionary = function Dictionary() {
    this.dict = {};
};
Dictionary.prototype['at:put:'] = function(index, value) {
    this.dict[index] = value;
};
Object.defineProperty(Dictionary, 'new', {
    get: function () {
        return new this;
    }
});

function st_eval(str) {
    var x = str.match(/(dict)\s+(at):\s+'(foo)'\s+(put):\s+'(bar)'/);
    var target = x[1];
    var callName = x[2] + ':' + x[4] + ':';
    var argv = [x[3], x[5]];
    var realTarget = eval(target);
    realTarget[callName].apply(realTarget, argv);
}

var dict = Dictionary.new;
console.log(dict);
//dict['at:put:']('foo', 'bar');
console.log(dict);
st_eval("dict at: 'foo' put: 'bar'");
console.log(dict);





--
View this message in context: http://forum.world.st/How-do-Smalltalk-disambiguate-messages-tp4918946p4918957.html
Sent from the Pharo Smalltalk Users mailing list archive at Nabble.com.

I tried so hard to find an example of Ruby using smalltalk message syntax.
You can do something like:

class Dictionary
    attr_accessor :dict

    def initialize()
        @dict = {}
    end

    def at(*args)
        if (args.length == 1) then
            return @dict[args[0]]
        end
        @dict[args[0]] = args[1][:put]
    end
end

dict = Dictionary.new
dict.at 3, put: 4
puts dict.dict
puts dict.at 3


But it's pretty expensive to disambiguate messages to "at" this way.

The JS approach was much simpler since each message like 'at:put:' or 'at'
were sent to appropriate receiver functions, whereas this is just a
spaghetti :\

I'm sure there's more elegant way of doing this in Ruby but I haven't found
it :|



--
View this message in context: http://forum.world.st/How-do-Smalltalk-disambiguate-messages-tp4918946p4918959.html
Sent from the Pharo Smalltalk Users mailing list archive at Nabble.com.

I define Magic as "An opaque abstraction or an abstraction you think is
opaque until you learn better.", to a beginner, everything is deeply
Magical.

That said, much of Smalltalk's opaqueness is not due to the language, but
due to me being a beginner. I'm sure there's a way to actually force sending
a message to a dictionary via something like dict['at:put:']('foo', 'bar')
but I am not familiar enough with Smalltalk to express it, so it feels like
the only way to send a message is via this multi-part message abstraction.






--
View this message in context: http://forum.world.st/How-do-Smalltalk-disambiguate-messages-tp4918946p4918966.html
Sent from the Pharo Smalltalk Users mailing list archive at Nabble.com.