kill(all);

block ([v_1, …, v_m], expr_1, …, expr_n) 
block evaluates expr_1, …, expr_n in sequence and returns the value 
of the last expression evaluated. The sequence can be modified by 
the go, throw, and return functions. The last expression is expr_n 
unless return or an expression containing throw is evaluated. 
Some variables v_1, …, v_m can be declared local to the block; 
these are distinguished from global variables of the same names. 
If no variables are declared local then the list may be omitted. 
Within the block, any variable other than v_1, …, v_m is a global variable. 

in effetti, la natura locale di a,b è di seguito preservata

a: GLOBAL_A;
b: GLOBAL_B;
c: GLOBAL_C;

block([a,b],a:1,a+b+c);

a;
b;
c;

tuttavia...

kill(all);

block(... , ... , ...) 

e semplicemente

     (... , ... , ...) 

non sono forme (come pensavo) equivalenti, ma si differenziano ad esempio
nel fatto che la seconda non gestisce l'eventuale natura locale delle variabili

a: GLOBAL_A;
b: GLOBAL_B;
c: GLOBAL_C;

([a,b],a:1,a+b+c);

a;
b;
c;

posso utilizzarle entrambe nei cicli for e per definire funzioni

block(...) senza dichiarazione di variabili locali

d:0;
for i : 1 thru 4 do block(
  d:d+i
);
d;

block(...) con dichiarazione di variabili locali

d:0;
for i : 1 thru 4 do block([d],
  d:d+i
);
d;

tentativo di dichiarare locale una variabile entro costrutto (...)

d:0;
for i : 1 thru 4 do      ([d],
  d:d+i
);
d;

utilizzo degli stessi costrutti fuori for

qui non rispetto il tentativo di dichiarare d locale

d:0;
([d],
  d:d+i
);
d;

qui viceversa rispetto la natura locale del "d" entro il blocco

d:0;
block([d],
  d:d+i
);
d;