Why do we distinguish between view and pure?

Question

I understand that the difference is that, while neither may change the state, view may read the state and pure may not. I also understand that it's useful to distinguish possibly state-changing functions from those guaranteed not to change the state.

My question is, why is it useful to indicate that a function won't even access state? Why doesn't view suffice?

Answer 1

If a function is pure, then no matter how many times you call it, if you pass the same parameters, it will always return the same value(s).

Example:

function pureFunction(uint a) pure returns(uint){
    return a + 5;
}

will always return 6 if you pass 1 as parameter a.

However, if the function is view, it's reading from the state, which may have changed since the last time you called it.

Example:

uint B = 5;

function viewFunction(uint a) view returns(uint){
    return a + B;
}

will also return 6 if you pass 1 as parameter a. But if another function modifies the value of B, then next time you call viewFunction(1), it will return something different.

Answer 2

I find the answer above confusing. It really boils down to this:

Pure does (can) not access state only memory/stack

View can access state but not make changes to it, just query (+ ETL).

No state changes in a transaction call means no gas cost, we're letting the compiler know that so we can get the right behaviour (sendTx vs call) after deployment.