in my oppinion it brings too much overload to the language syntax.
On the contrary, unlike inline variables it does not overload the "begin" and "end" keywords as block delimiters.
I think a feature like this is justified only if it brings considerable gains in performance.
That feature has nothing to do with performance. It wouldn't affect performance one way or the other. What that feature is about is localizing constant, type and variable definitions within a function/procedure. That means, instead of potentially having a significant number of locals, which turn out to be globals within the function/procedure/method, it would allow a much smaller number of locals because "throw away temporary variables" would be confined to the scope. That would make the code easier to understand and maintain.
By the way, would not this syntax cause some confusion with a possible future implementation of anonymous methods?
It shouldn't. Inline scopes should always be identified by a keyword to indicate their presence.
Delphi actually allows scoping inline variables if you put then INSIDE a nested begin..end block.
THAT is syntax overloading. "begin"/"end" are very poor block delimiters. The reason is, in a Pascal block, the programmer is supposed to be able to declare constants and types but, apparently these block features would not be available by overloading "begin"/"end". Overloading "begin"/"end" as block delimiters is just a hack. Another "writable constants" bright idea.
Type inference makes some assignments a little less redundant to write and adds simplicity to the code. The only negative point I see is the syntax that not follows the original Pascal concepts of declaring everything BEFORE the begin..end;
That's not the only potential problem with type inference. Pascal's strong type checking depends on explicit type declarations, type inference has the potential to create situations where the compiler would infer a type that is not the one the programmer had in mind.
However, I wish I could declare a variable in a loop like this in FPC:
With inline scopes you can do that and then some, all without altering the way variables are declared.
but I understand that if it costs turning the language into a Frankenstein, with various pieces without consistency, I prefer FPC stays the way it is.
Too late for that. If memory serves, writable constants were the first "Frankengimmick" that Borland put into Pascal and, unfortunately, far from the last one.
Fortunately, or maybe unfortunately, it's quite likely that the probability of seeing the Pope named the sexiest male on earth is likely greater than seeing inline scopes implemented in FPC.
hence I suggested for the latter example to create index as a keyword. The compiler can know that an index variable is required, even nested, and the ugly var is gone.
// in this case suppose index is a keyword, requesting the compiler to create it
for index := 0 to 4 do
for index := 3 to 7 do;
Effect is the same, but I believe the syntax is a lot cleaner..
And how would a two dimensional array "A" element be addressed ?... A[index, index] ? being able to address only the elements on the diagonals of square arrays doesn't seem to be a very useful "feature".
As far as controlling repetitions, that nested loop is basically a convoluted way of writing "for i := 1 to 25 do ;" The other examples you showed have the same problems.