Which popular object-oriented languages support readonly methods?

Question

I thought that many object-oriented languages have a reserved keyword for methods which do not modify the state of an object. These methods often have names that start with get. AFAIK a "getter" is always related to a single object attribute and "accessor" is too general, so "readonly" may the right term for this kind of methods (?). To give an example:

object Timespan {
    attribute start
    attribute end

    // getter, not changing the state
    readonly method getStart    { return start } 
    readonly method getEnd      { return end }

    // also not changing the state
    readonly method getDuration { return ( end - start ) }
}

The compiler/interpreter should check that readonly methods have no side-effect by modifying object attributes. I wonder why this language feature is not more common - just naming a method getFoo does not ensure that it won't modify the object.

Answer 1

In C++ you can declare const member functions. Such methods can't modify object state ( not even potentially, i.e. they can't call non-const methods of the same object), and this is ensured by the compiler.

Answer 2

What you want is const of C++. I generally find it extremely useful and don't understand why other languages don't have it, but they don't. The only other language I know to have something similar is D, but the differences in semantics, while making it more useful to optimization, make it less useful for restricting interfaces.

In other languages like Java and C#, the only thing you can do is create an interface with the constant methods only, implement it in the object and downcast to that interface if you want to pass the object but not allow modifying it. Unlike C++, you won't get compiler checking the methods are in fact constant.

While the interface will serve the ultimate goal of being able to pass the object by reference and still being able the other code will not modify it, using an interface means always incurring the virtual call overhead while in C++ it's purely compile-time affair.

Answer 3

A method that does not have any observable effect on the state of the object is commonly known as a "pure" method. The key word here is observable. In the case of lazy instantiation or caching - these effects would not necessarily be observable to the consumer, so the method would still be considered a pure method.

In C# (and other languages which support meta data), you can declare an attribute on a method which marks it as pure, and static analysis tools can be used to warn you if it isn't (or more usefully, if it regresses from being pure).

see: http://msdn.microsoft.com/en-us/library/system.diagnostics.contracts.pureattribute.aspx

Answer 4

Python:

@property
def foo():
    return self.__foo

C#:

class Foo
{
    public int bar()
    {
        get
        {
            return 1;
        }
    }
}

It's true that the Python example does not technically make things read-only, but "support" it is. A mechanism to communicate to other programmers that the method is read-only counts as support. And no, it does not simply have to be a trivial getter that only returns an instance field.