> The problem in Pike is that the intended lifetime of the variable
> isn't always obvious; consider nested classes:
>
> class X {
> int inc()
> {
> static int counter;
> return counter++;
> }
> }
>
> int main()
> {
> function(:int) X1 = X()->inc;
> function(:int) X2 = X()->inc;
> write("X1:%O,%O\n"
> "X2:%O\n",
> X1(), X1(),
> X2());
> }
>
> Should the above output X1:0,1 X2:0, or X1:0,1 X2:2? ie should the
> variable be stored in X or in the top-level class?
My intuition says storage should be where it was declared, i e X1:0,1
X2:0 with the above example. Given the proposed semantics, for:
class X {
static int counter;
int inc()
{
return counter++;
}
}
...I would consider X1:0,1 X2:2 be the correct corresponding output.
You don't state whether this case, where the "static" modifier already
has semantics tradition in Pike, will do the same thing, though. Would
and should it?
> Pike also has nested functions; consider:
>
> function(:int) X()
> {
> int inc()
> {
> static int counter;
> return counter++;
> };
> return inc;
> }
>
> int main()
> {
> function(:int) X1 = X();
> function(:int) X2 = X();
> write("X1:%O,%O\n"
> "X2:%O\n",
> X1(), X1(),
> X2());
> }
>
> Same question.
I'm less opinioned here; I would not mind X1:0,1 X2:2 in this case, or
the first option, as long as which result you'd get is guaranteed.
> I believe that the most useful would be to store the variable in the
> closest surrounding scope (ie X1:0,1 X2:0 for both of the above),
> and then have some extra syntax for specifying some other scope.
I think the most useful is the most readable (least susceptible to
misunderstanding, when the code is read by humans). Which one that is,
I don't know; I'm just one data point there. I can understand and to
some extent appreciate that the proposal above would be the easiest to
implement / maintain, if that is what you meant, but since you suggest
supporting both, it probably wasn't. :-)
|
