Can operators in Smalltalk be overloaded?

Is it possible to overload operators in Smalltalk?

I am looking fo开发者_StackOverflow中文版r tutorials/examples.

Thanks.

Method overloading is not possible in Smalltalk. Instead, a combination of method overriding and a technique called double dispatch is used to implement the same behavior as operator overloading in other languages.

You can find an example implementation in the mathematical operators +,*,/,- (which are binary messages in Smalltalk). Here is the idea: the implementation of Integer>>+ sends a message #addWithInteger: to its argument. The implementation of #addWithInteger: is implemented on each Magnitude subclass, such as to specialize addition of Int+Int, Float+Int, etc...

For most part, things that are operators in other languages are in Smalltalk unary or binary messages like +, *, /, ... etc. Classes are free to respond to those messages as they seem fit, so yes, you can redefine behavior of +, and you can also make instances of some non number classes understand and respond to it.

For instance look at the implementation of + in Point class.

One thing to note, := and ^ are not messages, so they can not redefined in a way described above.

Btw, for learning Smalltalk, one of the greatest resources of examples and code is the Smalltalk image. So I recommend that you fire up Smalltalk, and learn your way to browse through vast amount of examples that it contains.

There's no operators in smalltalk, except assignment. Everything is implemented in classes as methods. So if you want to change behaviour of = or + / - methods, just look at their implementors. Or if you want to make instances of your class to understand those messages, just implement them.

The operator-overloading tag is defined on Stack Overflow as

a feature of a programming language that allows custom implementations for operators depending on the types of the operands involved. Some languages allow new operators to be defined while others only allow redefinition of existing ones.

In Smalltalk
All types are defined as classes of object *
All operators are methods *
All methods are executed by the receiver of the message with the method's name
All methods can be over-ridden

So any operator, operating on any operand, can be over-ridden by any developer.

Here are some examples:
Objects of Class Float, Class SmallInt, Class Fraction and Class Point can all respond to a + message. They can interroperate with one another, too.
aFloat := 3.1415 . aSmallInt := '6' . aPoint := 3@3 . aFraction := 22/7 .

"send the + aSmallInt message to aFraction"
aSum := aFraction + aSmallInt Evaluates to: 64/7

"send the + aFraction message to aSmallInt"
aSum := aSmallInt + aFraction Evaluates to: 64/7

aSum := aFloat + aFraction aSum := aFraction + aFloat These evaluate to: 6.284357142857143

aSum := aFloat + aSmallInt aSum := aSmallInt + aFloat These evaluate to: 9.1415

aSum := aPoint + aSmallInt aSum := aSmallInt + aPoint These evaluate to: 9@9

In effect, we have 8 different implementations of the + operator on display here, each customised to deal with the types of the operands involved.

The caveats: * Objects are not strongly typed. Any variable of one type can be changed to any other type, and the system will not raise an exception. An object can start as an object of Class SmallInt and then be changed to a ByteString or a Dictionary, and the system will not raise the slightest warning. Until it is sent a message that it does not understand.

There are 6 primitives that are not an object or Class of object: true, false, nil, etc.

There are two operators which are, in effect, syntactic sugar for named methods.

Smalltalk doesn't have operators but you can achieve a similar thing via method definition/overriding:

Object subclass: Foo [ 
  + anObject [
    "define new behavior for + here"

  ]
]