Set type parameter

[simsee]

Just out of curiosity: (see code) why can I have a parameter of type array of char, but not of type set of char and consequently must, in this second case, first define a new type? Thank you.

Code: Pascal  [Select][+][-]

1. program Project1;
2. {$mode ObjFpc}
3.  
4. procedure Proc1(P : array of char);
5. begin
6. end;
7.  
8. procedure Proc2(P : set of char); //error
9. begin
10. end;
11.  
12. begin
13. end.

[Blaazen]

Everything should be declared before you use it (in Pascal). Open arrays are exception.

[Kays]

As a matter of fact you always need to specify a data type name (for value and variable parameters); “anonymous” data types are not permitted in the formal parameter list. The FPC – as extension – just allows (“open”) array of …, too, as you can see in the syntax diagram.

[Warfley]

As already hinted by the previous two posters:

Code: Pascal  [Select][+][-]

1. procedure Proc1(P : array of char);
2. begin
3. end;

This does not define a function that takes a dynamic array as parameter, but is an open array, which is it's own type and semantic concept. It is a different type from when you use "array of ..." in a variable definition.

For example:

Code: Pascal  [Select][+][-]

1. procedure DynamicArray(arr: TStringArray);
2. begin
3.   SetLength(arr, 3); // Works because it is a dynamic array
4. end;
5.  
6. procedure OpenArray(arr: array of String);
7. begin
8.   SetLength(arr, 3); // Doesn't work because not an dynamic array
9. end;  

Simply put, the construct "array of type" can be different things depending if it is in a parameter list or in a type definition

[Blaazen]

The FPC – as extension – just allows (“open”) array of …,

Isn't it for Delphi compatibility rather than FPC's own extension?

[Kays]

The FPC – as extension – just allows (“open”) array of …,

Isn't it for Delphi compatibility rather than FPC's own extension?

Indeed the notion of open arrays are of Borland Pascal’s origin. The wording wasn’t suggesting (or wasn’t meant to suggest) open arrays were FPC’s original idea. It is nevertheless an extension to Pascal. Some compilers support it, others don’t. Don’t be surprised if it doesn’t work with a different compiler. I just wanted to point that out.

[simsee]

Thanks a lot for your explanations. An open array is not a type. However, the notion of open array has always seemed a bit strange to me. Wouldn't it have been easier to treat this kind of situation as a dynamic array type parameter?

[Warfley]

I think that open arrays are one of the contenders for the worst constructs introduced to pascal. They look like dynamic arrays, behave in 80% of the time like dynamic arrays, and the only way most people find out that they are something different is by trying to use them as a dynamic array and it failing in the other 20%. It's not just not intuitive, this is counter intuitive design.

But open arrays actually have a bit of a justification for their existance. They allow to define a fixed but arbitrary number of parameters at compiletime. A dynamic array will be created at runtime, when you create a dynamic array of int with "[1, 2, 3]", it will allocate memory for 3 ints on the heap and fill that array. An open array on the other hand can be prepared more flexible. An open array is afaik nothing other than just 2 pointers, one pointing to the first element, one pointing to the last element. So for example the compiler can push the parameters on the stackframe for the called function and pass those parameters. If the parameters are constants, the compiler can create this as a hidden variable and pass those parameters to it.
It also works out of the box with both static and dynamic arrays, while if it were just a dynamic array, any static array would first need to be copied to a new memory location for the dynamic array.

As an example on how this looks compiled, check out this simple example: https://godbolt.org/z/6hGPP58nc

Code: Pascal  [Select][+][-]

1. function Sum(arr: array of Integer): Integer;
2. var
3.   i: Integer;
4. begin
5.   Result := 0;
6.   for i:=Low(arr) to High(arr) do
7.     Result += arr[i];
8. end;
9.  
10. procedure ReadAndSum;
11. var
12.   a, b, c, s: Integer;
13. begin
14.   ReadLn(a);
15.   ReadLn(b);
16.   ReadLn(c);
17.  
18.   s := Sum([a, b, c]);
19.   WriteLn(s);
20. end;

What happens to call sum is the following:

Code: ASM  [Select][+][-]

1.         movl    %r12d,8(%rsp)
2.         movl    %r13d,12(%rsp)
3.         movl    %r14d,16(%rsp)
4.         leaq    8(%rsp),%rdi
5.         movl    $2,%esi
6.         call    sum(array_of_longint)

As you can see, the 3 variables are pushed onto the stack, before calling the sum function. This way the whole construction of an dynamic array can be avoided.

Also not to mention they allow in the cdecl calling convention to be used as varadic function arguments to be compatible with C (e.g. for using or being used by other libraries or code)

So while I would fully agree that open arrays are not well designed, because of the fact that they are really unintuitive, the idea behind them is not that bad and they are actually useful

[Thaddy]

As far as I know it is not a Borland extension but part of ISO 7185 Pascal:

Code: Pascal  [Select][+][-]

1. {$mode ISO}
2. procedure Proc1(P : array of char);
3. begin
4. end;
5. begin
6. end.

FreePascal is usually rather strict with ISO.
Dynamic arrays, however, are not part of ISO and introduced much later and indeed by Borland.

So if there is any syntactic confusion, blame dynamic array syntax. IOW it is the other way around as has been written above.

The remarks about typing are correct, btw and the recommended way to handle strongly typed dynamic array parameters over array of const and/or open array parameters.

The above example also works in P5, which is more or less the reference implementation for ISO Pascal.
(And P5 compiles in FreePascal  )

Maybe Scott Franco can give you even Moore info (the latter is an inside joke). He is the in-house expert on ISO modes and a - occasionally visiting - forum member and author of many ISO compatible code, including P5. He is the one that stimulated Florian to pursue full ISO compliance.

[Kays]

As far as I know it is not a Borland extension but part of ISO 7185 Pascal:

Thaddy, you don’t know if you evidently haven’t read the standards. ISO 7185 level 1 defines “conformant array parameters”. They look like this:

Code: Pascal  [Select][+][-]

1. procedure foo(bar: array[minimum..maximum: integer] of integer);

Unlike the GPC, the FPC does not disable “rudimentary” features/extensions. Hence the ISO-modes compile (or ought to compile) a superset of ISO Pascal.

But open arrays actually have a bit of a justification for their existance. […]

Conformant array parameters provide the same advantages you mentioned. The only justification that matters is the sacred “Delphi compatibility”.

[Warfley]

They look like this:

Code: Pascal  [Select][+][-]

1. procedure foo(bar: array[minimum..maximum: integer] of integer);

That is actually a really cool syntax, sadly it is not used anymore

[PascalDragon]

Thanks a lot for your explanations. An open array is not a type. However, the notion of open array has always seemed a bit strange to me. Wouldn't it have been easier to treat this kind of situation as a dynamic array type parameter?

No, because open array parameters allow you to construct these arrays on the fly (which till recent Delphi and FPC versions was not possible with dynamic arrays):

Code: Pascal  [Select][+][-]

1. SomeFunc([42, 21, 7])

Also open array parameters support that you pass a single value:

Code: Pascal  [Select][+][-]

1. var
2.   v: LongInt;
3. begin
4.   SomeFunc(v); // note the missing [...]
5. end;

Internally in contrast to dynamic array types (which are data structures contained on the heap) open array parameters are simply a pointer to the first element and a hidden size parameter.

[440bx]

...simply a pointer to the first element and a hidden size parameter.

size or element count ?... I was under the impression it was element count, correct me if I'm wrong.

[Blaazen]

The second parameter is count-1.

[440bx]

The second parameter is count-1.

Yes, you're right.  Since it's zero based, it's not strictly a count.