4 ms·

Not really. In fact in Lisp OO is the opposite, the functions are explicitly keeped away from the data. For Alan Kay it was all about messanging but I dont thi

• crimsonalucard 8y ago
  Are you saying instead of this: def method(): this.value = this.value + 1 lisp does something like this? def method(object): object.data = object.data + 1
  • TeMPOraL 8y ago
    Yes. Note that `this` is just syntactic sugar; a call to `obj.method(arg)` is, underneath, essentially a call to `method(obj, arg)`, with the first argument always being hidden, and the only one that's a subject of a method dispatch (polymorphism). Common Lisp gets rid of implicit `this` by making all arguments explicit, and by not restricting polymorphism to the first parameter - in fact, you can do a method dispatch on any of the method parameters, or any combination of them. See https://news.ycombinator.com/item?id=18848384 https://news.ycombinator.com/item?id=18848384 for an example.
  • nickik 8y ago
    Yes. But while this is single dispatch. The real clue is that you can have multiple dispatch. So you might have. define generic inspect-vehicle (v :: <vehicle>, i :: <inspector>) => (); define method inspect-vehicle (v :: <vehicle>, i :: <inspector>) => () look-for-rust(v); end; define method inspect-vehicle (car :: <car>, i :: <inspector>) => () next-method(); // perform vehicle inspection check-seat-belts(car); end; define method inspect-vehicle (truck :: <truck>, i :: <inspector>) => () next-method(); // perform vehicle inspection check-cargo-attachments(truck); end; This is Dylan code, but its the same concept, easier to read compared to CL. See: https://opendylan.org/documentation/intro-dylan/multiple-dispatch.html https://opendylan.org/documentation/intro-dylan/multiple-dis... Once you start thinking about dispatch in a broader sense the advantage is clear.
• TeMPOraL 8y ago
  > Not really. In fact in Lisp OO is the opposite, the functions are explicitly keeped away from the data. Common Lisp really opened my eyes here. Initially it felt weird to have methods[0] living completely independently from classes, but over time I realized that where classes and objects implement nouns, generic functions and methods represent verbs, and in a language the verbs are an independent domain from nouns, representing their own generalized concepts that's unrelated to the taxonomy of nouns. -- [0] - A "method" in CLOS is an individual implementation of a "generic function". So e.g. you could have a generic function `(defgeneric draw (device figure))`, and then specific implementations dispatching on any combination of arguments; e.g. `(defmethod draw ((device printer) figure)` to draw any kind of figure on a specific device, or `(defmethod draw (device plotter) (figure circle))` to draw a specific thing on a specific device, etc.