Re: in defense of GC

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Markus E Leypold
<development-2006-8ecbb5cc8aREMOVETHIS@ANDTHATm-e-leypold.de> writes:

> I do need that
>
>   function Make_a_Stepper (K:Integer) return ... is
>
>       N : Integer := Complicated_Function(K);
>
>       function Stepper(F:Foo) return Foo is
>     
>         begin
>           
>           return Foo + N;
>
>         end;
>
>     begin
>       return Stepper;
>     end;
>
> would work. And no nitpicking, please, if I made syntax error here: The
> intention should be clear.

I don't think this is nitpicking:

I'm not sure what you mean by the above example.  Is N intended to be
constant or variable (in Ada terms -- that's immutable/immutable in FP
terms)?

Do you mean this:

  function Make_a_Stepper (K:Integer) return ... is
      N : constant Integer := Complicated_Function(K); -- I added "constant" here! ****************
      function Stepper(F:Foo) return Foo is
        begin
          return Foo + N;
        end;
    begin
      return Stepper;
    end;

Or this:

  function Make_a_Stepper (K:Integer) return ... is
      N : Integer := Complicated_Function(K);
      function Stepper(F:Foo) return Foo is
        begin
          N := N + 1; -- I added a modification of N here! ****************
          return Foo + N;
        end;
    begin
      return Stepper;
    end;

?

These two cases of so-called "upward closure" seem very different to me.
(Both are of course illegal in Ada, but we're discussing what "ought" to be.)

In the former case, we're returning a function that looks at some local
value (the value of N).  In this case, you comment about returning
integer values is quite correct:

>> Closure don't "make things global". They do it as much as returning an
>> Integer, makes, GOD FORBID!, a value global (don't return Integers
>> people, that makes a value global and we all know, global is bad --
>> how nonsensical is that?).

Right.  What's the big deal?  Returning a function that looks at integer
values is no worse than returning integer values.  Integer values live
forever, and the value of N is certainly not tied to the lifetime of N.

But in the latter, case, the return of Stepper is causing the lifetime
of an integer VARIABLE (i.e. mutable) to be longer than one might
suspect for a local variable of Make_A_Stepper.  That seems like a
problem to me.

You (Markus) seem to be an advocate of (possibly-upward) closures.
And also an advocate of function programming.  So how would you like a
rule that says the former example is OK, but the latter is illegal?
(That is, upward closures are allowed only when you're doing functional
(no side-effects) programming).

Note that the latter is not functional -- a call to the function that
Make_A_Stepper returns modifies N, which is the key difference!

- Bob