Can record constructors make record constants more concise?

Question

I have some tabular data:

Foo       Bar
-------------
fooes     42
bars      666 
...

So, I declare the entity structure:

type TFoo = record
  Foo: string;
  Bar: Integer
end;

and the table of entities:

const FOOES = array [M..N] of TFoo = (
  // Have to specify the field names for each record...
  (Foo: 'fooes'; Bar:  42),
  (Foo: 'bars';  Bar: 666)
  { so on }
);

As you see, this looks quite verbose and redundant, and it is because I initialize all of the fields for all of the records. And there is a lot of editing if I copy tabular data prepared elsewhere. I'd prefer to not enumerate all of the fields and stick to the more laconic C style, that is, constants only. And here comes the record constructor...

Can record constructors help me in this case?

Here's an example in C. You'll notice that we don't have to specify the field names in each declaration:

#include <stdio.h>

typedef struct {
        char    foo[10];
        int     bar;
} foo;

int main(void) {
        /* Look here */
        foo FOOES[2] = {{"foo", 42}, {"bar", 666}};
        int i = 0;
        for (; i < 2; i++) {
                printf("%s\t%d\n", FOOES[i].foo, FOOES[i].bar);
        }
        return 0;
}

Answer 1

A const is just a read-only var which is loaded/mapped within the code, when the executable is launched.

You can create a var record (or a const but overriding the writable const option), then initialize it in the initialization section of the unit.

var FOOES = array [M..N] of TFoo;

....

initialization
  SetFooArray(FOOES,['fooes',42,'bar',230]);
  ...
end.

The custom SetFooArray() function will put all array of const parameters into FOOES.

I use this technique sometimes to initialize computable arrays (e.g. conversion or lookup tables). Sometimes, it does make sense to compute once at startup a huge array, saving some KB of const in the source code, with a few lines of code.

But I'm not sure it will be worth it in your case. The default const declaration is a bit verbose, but not a problem if you use Ctrl+C/Ctrl+V or a find and replace. It is the most standard, is secure if you change later the record layout (whereas the C construction may compile without error), and will create a true constant.