Are operators just “special” methods?

Question

Here's what is meant by operators and methods.

Attempting to keep the questions as simple and open ended as possible, since the question is more about the conceptual nature of operators and methods NOT how a language has decided to implement them.

Proof of Concept: This example in Ruby is more of a proof of concept than anything else. EXAMPLE: In Ruby, "1+2" is equivalent to "1.+(2)", meaning the object "1" implements a method called "+" with object "2" as the method's argument.

Answer 1

Some languages (SML of NJ comes to mind) allow you to declare functions as "infix". In this case a "function" and an "operator" are pretty much identical, differing only in notation. I can neither recall nor google up the source, but I've read an essay claiming that Combinatory Logic has, as its (philosophical) roots, the desire to make "operators" the foundation of mathematics.

I think you'll probably get a lot of bad arguments both for and against the idea of operators being identical to functions. The arguments will feel similar to arguments about "what's an object?", except that mathmatically, "function" and "operator" really are identical, while "object" doesn't have a good mathematical foundation.

Answer 2

Operators are not always identical to functions, since their semantics could be significantly different from a plain function call semantics. For example, sizeof(...) operator in C does not evaluate its argument. Ternary operator (x?y:z) always evaluate only two of its arguments. Logical operators (&&, ||) may not evaluate second argument.

And even the plain arithmetic operators might have complicated implicit type casting behaviour.

For this reason, you can't define operators as functions, at least in an eager language. Lazy languages are different, but still, you won't be able to define something like sizeof(...) as a function.

Answer 3

At least in Haskell, an operator is a symbol function with an arity of at least 2. (Although there is an extension that lifts this restriction) You can define your own operators, overload them via type-classes, give them precedence and associativity etc... After all, by putting parenthesis around an operator, you can use it just like any other (prefix) function. You can even use an ordinary function as an operator by encapsulating it in backticks.

Here are some (silly) examples:

(.:) :: (a -> b) -> (c -> d -> a) -> (c -> d -> b)
(.:) = (.) . (.)

(§) = negate .: (*)

-- or similiar

a § b = - (a * b)

infixl 7 *
infixr 9 .:

Answer 4

It is highly dependent on language.

Most high level function languages they are identical.

For interpreted languages there is usually little difference (especially when the language allows you to write your own operators (then it is just syntactic sugar for a method call), but then an interpreted language all operators are basically method calls as the language is interpreted).

When it comes to languages like C++ the story gets more complex.

• operators on primitive types are not like method calls.
• operators on class types are just that: method calls.

There is important distinction as this can change the inherent expected behavior of the operator. For example the && and || opertors are shortcut operators when used on primative types. But when you override for a particular class they are now the equivalent of method calls and thus all parameters must be evaluated before the method is called and thus they are no longer short-cut operators.

When using methods (and thus class specific overloaded operators) you have specific guarantees about where the sequence points are (thus certain side effects are OK). But with normal operators there are usually no sequence points until the end of the expression (thus side effects have a much larger scope for interfering with the rest of the expression).

Answer 5

In addition to the other answers here, which cover a lot of good examples, here's another bit.

In C++, for example, some operators have to be defined outside of a class's definition, and are thus 'free functions' with a left-hand-side and a right-hand-side (2 arguments).

So in this case they aren't even "Methods", as they are not defined inside any class.

Answer 6

At least in Scala operators are functions methods. You can use a method which takes single parameter as infix operator (see A Tour of Scala: Operators and Scala for C# programmers, part 6: infix operators

Answer 7

First, understand that a "method" is nothing but a function. (Please do not confuse "method" with "method overloading", "method dispatch" etc. which are indeed nice language features.)

Second, understand that an operator is nothing but a function with a funny name and special support from the parser so you can write them pre-, post- or infix.

Hence, it is quite correct to say that operators are "special methods".