Re: Recursion, Yo

On 14.04.2024 02:29, Michael S wrote:

On Sun, 14 Apr 2024 00:23:44 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
 

Michael S <already5chosen@yahoo.com> writes:
>

On Sat, 13 Apr 2024 00:13:36 -0000 (UTC)
Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
 

On Fri, 12 Apr 2024 14:35:47 +0200, Janis Papanagnou wrote:
 

It seems that's one of the fundamental differences between
(low-level) languages that want to provide such technical factors
explicit to the user and between languages that want to provide a
higher abstraction.
>
Algol 60, Pascal, Simula 67 and Algol 60, Eiffel, etc. all took
that approach.   

>
Pascal had explicit pointers, though. Algol 68 and Ada did not. 

>
Of course, Ada has pointers. The are called access types.
https://en.wikibooks.org/wiki/Ada_Programming/Types/access
>
I never learned Algol-68, but considering your reputation I'd want
to see confirmation from more reliable source. 

>
I suppose it all depends on what constitutes a pointer, but Algol 68
has pointers to this extent:
>
BEGIN
   INT i := 42;
   [3] INT a := (1, 2, 3);
>
   REF INT p := i;   CO p is a "pointer" to i
CO REF INT(p) := 99; CO changes i via p
CO p := a[2];        CO p now points to the second element of array a
CO REF INT(p) := 99; CO change that element via p
CO
>
   print((i, a[1], a[2], a[3]))
END
>
I'd call p a pointer.
>

 
Thank you.
It looks closer to C than to Pascal, i.e. pointer can point to any
object rather than just to dynamically allocated object.

The major difference is that they are closely bound to the type.
In that respect they are more like Pascal pointers. C pointers
open the can of issues with arithmetic on pointer values. You
don't find that in Pascal or Algol 68. WRT 'REF' you have to
understand that it's a sort of "technical" reference item that
is used to link structures as pointers do. And besides that you
also have allocators for stack or heap objects. You combine the
two to get what you have in other languages. Usually you don't
see the stack allocator because Algol 68 allows abbreviations
to write only brief declarations what we also know from other
programming languages. For example the following are the same

  INT a := 42;

  REF INT a = LOC INT := 42;

It says that a is an integer 'REF' ("lvalue"), identical to a
local (stack) item - where LOC is the generator -, and finally
the value assigned.

You can replace the 'LOC' by 'HEAP' if you want the heap generator
to allocate the memory. For example

  HEAP INT a;

  REF INT a = HEAP INT;

In Algol 68 (as in Pascal) these references are bound to the type
(in the above examples to 'INT').

Janis