It would seem to me that this should be equivalent to the above, with the {x,-1,0} range:

Clear[f];
Do[f[x, y, z] = (x + y + z + 10)^2,
  {x, -1, 0}, {y, 0, 2}, {z, 0, 2, 2}];
?f

The numbers are the same, but with "=" instead of ":=". The DownValues are exactly the same. Why does ?f format the output differently in the two cases, from the very same information?

Thank you for taking the time to inform us about this issue. I've forwarded the example to the developers.

For the majority of cases, you should always avoid programmatically defining down-values of functions. It's impossible in most programming languages and in any language I know where it is possible, not encouraged. That said there are cases where it's apparently unavoidable.

You can see a similar issue here: https://mathematica.stackexchange.com/questions/188517/distributedefinitions-is-evaluating-the-definitions-and-this-only-for-a-large-n

Memoization, if you want to view it as programmatically creating function definitions, is a least a very very limited form of it. And in most languages that have memoization it's not done as a side-effect of the evaluation of the function, but instead it's a language level feature. Even in Python, where you're likely to do with a decorator, you hide any obvious state and try to make it look like it's a language level feature. I'd saw the WL is pretty unique in having such an explicit and structurally obvious syntax for it.

The only reason it's not more commonly advised against, AFAIK, is that it's basically impossible to define a function in a loop like this in most languages. The closest I've seen in production code was a loop calling a factory. You have to use some very heavy abstraction to effect it.

Overall, programming advice is subjective, but I think the fact this is widely disallowed in most styles is a pretty solid sign. Most cases of this I've seen in WL tend to involve Symbolize and the creation of unique function names or the attempt to use Indexed/Subscript in some way.

I use it often as a way of caching values needed for lookup later. For example, say you wanted to implement the default version of DeleteDupolicates in the Wolfram Language. (I use this as an example because it was proof-of-concept code once upon a time for why/how we should improve on our shabby O(n^2) method then in use.)

Obviously, my original program is not just for numbers. On the right hand side of the definition there could be global variables. But this is not essential to demonstrate the bug.

The situation is as follows. For each set of arguments, the calculation will take a long time. Because the arguments can be enumerated, I want it to be partly evaluated in the definition for each set of arguments. I will copy the results and run separately, and thus given each set of arguments it may not run a long time when the other global variables are set on the right hand side. It seems that "=" also do the same thing as long as it is run before the global variables are set. Anyway, I prefer to use ":=" in the definition and just met this bug.

I don't know whether there are better way to do this.