Does a pure method have to be static?

Question

I'm working through a textbook at the moment which defines a pure method as:

"a static method that depends only on its parameters and no other data"

Would it not be possible to have an instance method be a pure method without it being static (as long as it doesn't modify parameters and doesn't have 'side-effects' like printing)?

I know for a pure method to be the pure, the return value only depends on the parameters and not on any other state, so perhaps the way instance methods are called means that the variables taken from the object calling the method don't count as parameters but as another "state"?

Other than that I can't think of any reason why a non-static method couldn't be a pure method.

Here's an example:

public class Rational {

    private int numer;
    private int denom;

    public Rational() {
        this.numer = 0;
        this.denom = 1;
    }

    public Rational(int numer, int denom) {
        this.numer = numer;
        this.denom = denom;
    }
}

The above defines a Rational class

You could then write a method in the Rational class which returns a Rational object as a double by either 'Method one' or 'Method two' below.

Method one:

public double toDouble() {
    double x = this.numer;
    double y = this.denom;
    double fprat = x / y;
    return fprat;
}   

Method two:

public static double toDouble(Rational rational)
{
    double x = rational.numer;
    double y = rational.denom;
    double fprat = x / y;
    return fprat;
} 

They essentially do exactly the same thing but one is a static method and the other is an instance method so their calls would be in a different format. Method two is certainly a pure method but would Method one, which is non-static, also be defined as a pure method under these circumstances?

Answer 1

The "static" part of that definition is superfluous. A method being static doesn't guarantee that it does not rely on any other state. I suspect the definition just wanted to make sure the method does not use instance variables.

On the other hand, technically you may also think of an instance method as a static method with a zero-th parameter, the object itself. If that object is immmutable (or the method does not change anything in the object), you could argue that the method is still pure. Basically you regard the "object" as an additional parameter.

Method references in Java for example can behave this way, making the first argument the object itself on which the method is called.

Answer 2

A pure method might as well be static. The two criteria for a pure method are, according to Wikipedia:

1. The function always evaluates the same result value given the same argument value(s). The function result value cannot depend on any hidden information or state that may change while program execution proceeds or between different executions of the program, nor can it depend on any external input from I/O devices.

2. Evaluation of the result does not cause any semantically observable side effect or output, such as mutation of mutable objects or output to I/O devices.

(emphasis mine)

There's no reason why this cannot apply to a non-static method. Making the method static would give a caller stronger guarantees that no instance state was being used, so it's probably better to make it static.

---

Depending on your perspective, one could view an instance method as simply a function taking an extra implicit argument: the instance itself. In this way, a non-static method could rely on instance state and be considered pure, provided it didn't rely on any external state (singletons etc) or produce side effects. Robert's answer puts it nicely. This is up to interpretation, but my person opinion is that such a method would be pure.

Voo put it nicely in the comments:

Why should a hidden this pointer be considered any more special than any other parameter to the function? That argument leads to a contradiction: Assume that
public static int pureFunc(MyInstance self) is pure, clearly the isomorph
public int pureFunc() would be pure as well.

Answer 3

Conceptually, the only difference between a static method and an instance method is that instance method has a hidden parameter accessible through this keyword.

Therefore an instance method that does not mutate this is pure if it would otherwise qualify as a pure static method.

The issue here may be rather related to virtual dispatch which is prevented by static. A base class method may be pure whilst a derived class method may be impure while their contract in the Java type system is equal.

Answer 4

"Pure" basically means "depends only on its arguments and has no side-effects".

A static method doesn't have to be pure since it might access a static data structure. In the same way, an instance method may be pure since it doesn't access any instance variables.

So the concepts of "static" and "instance" aren't directly related to the concept of "pure".

Answer 5

This method:

public int add(int a, int b) {
   return a + b;
}

is not static but its return value does not depend on anything except the parameters. But because of this, add doesn't need to be an instance method at all!

I think this is what your textbook is getting at - instances methods that does not access the state or mutate the state may as well be static.

Instances methods are supposed to depend on the state of the object, otherwise it should be a static method. And static methods that doesn't depend on static states are pure.

Answer 6

There is no guarantee that a static method is pure. Technically a static method can have a static state. That's why your assumption

"a static method that depends only on its parameters and no other data"

is not true.

EDIT after Bergi comment

As I said before, the static keyword doesn't guarantee stateless. If you omit the static keyword in your quote, it still will be true.

So answering your question. Does a pure method have to be static? The answer is it depends.

There are benefits from making pure function static, i.e.:

• It's a self-check, which guarantees that you don't (accidentally) change state in your class;

• The method cannot be overridden. Which guarantees that the method won't change state in the future.

But on the other hand, it's difficult to mock static methods and it can be a problem during testing.