I'm using C++ concepts to ask the question because that's where it came up, but I'm asking about any language feature or tool that would somehow support this.

Suppose I have a class that's a light wrapper around a list of values. These values are expensive to compute, so they're computed as they're asked for. The object has all the information it needs to compute the values at construction time.

objectInstance.get(5) will always return 10, but the get method cannot be const because it will add a value to the internal list the first time it's called.

What support is there for such "effectively-const" methods?

  • What about caching the result in a dictionary with the input as key?
    – JanDotNet
    Jun 18, 2017 at 7:22
  • 1
    So, like mutable in c++? Or should the language guarantee it always returns the same value?
    – Bwmat
    Jun 18, 2017 at 8:03
  • Some languages support "lazy" variables one way or another.
    – gnasher729
    Jun 18, 2017 at 16:15

1 Answer 1


Effectively what you’re looking for is a way to present an entity as immutable through its public API but still allow mutable state as an implementation detail behind the scenes.

Sometimes that’s a valid design choice, but do not use is lightly. Especially – since you promise the caller immutability – make absolutely sure that after the entity is created it does not change its publicly visible state ever.

I can think of two situations where such hidden mutability is a valid approach.

  • For lazy evaluation like in your own example.
  • For internal state that needs to be mutable for administrative/housekeeping purposes. A straight forward example is acquiring and releasing a mutex (i.e. changing its state) to read a variable in a thread-safe manner.

I can’t give you an overview over how “internal mutability” is supported in a lot of languages because I mostly know C++ and Python, and I’m starting to dabble a bit in Rust.

In Python constness in the sense of your question does not exist at all, so special support for internal mutability is not needed.

In Rust Cell and RefCell seem to be the things to looks for.

In C++ the language provides the mutable keyword (and sometimes an argument can be made for const_cast):

class Entity
    explicit Entity(int i): m_i_might_be_const(i) {}

    int get_mutable() const
        return m_i_can_change;

    int get()
        return m_i_might_be_const;

    // Fails to compile with a message like:
    // "Const member function cannot change object’s state."
    int get_error() const
        return m_i_might_be_const;

    mutable int m_i_can_change = 0;
    int m_i_might_be_const;

int main()
    const Entity e(42);

    // Works because m_i_can_change is mutable
    auto a = e.get_mutable();

    // Fails to compile with a message like:
    // "Calling non-const member function on const object e."
    auto b = e.get();

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.