//given following situation:
type record of integer RoI;
 
var RoI vroi := {1,*,5}
vroi[2] := 2; // is this allowed or does the same rule apply like in case of vroi := *
 
vroi := {?,2,*}
vroi[3] := 4; // is this allowed, and if yes, would the outcome be something like {?, 2, <uninitialized>, 4, *}
 
vroi := ?;
vroi[1] := 2;// this for instance is allowed and would produce the same template as in the previous initialisation of vroi: {?, 2, *}
vroi[3] := 4; // this case seems to be allowed too and it would produce a vroi: {?, 2, ?, 4, *}

var template RoI vroi := {1,*,5}
vroi[2] := 2;

vroi[1] := 0; // vroi -> {1, 0, 2}    is this correct?

var template RoI vroi := {1,*,5}
log(vroi[1], vroi[2]); // -> "*5"

t_RoI := {permutation(0,1,3,* length(2)),2,?}
t_Int := t_RoI[5];

t_RoI := {0,1,3,* length(2),2,?}
t_Int := t_RoI[5];  // t_RoI[5] == ?

var template RoI vroi := {1,*,5}
vroi[2] := 2; // ->{1,*,2}
vroi[1] := 3; // -> {1,3,5}

var template RoI vroi := {0,1,3,* length(2),2,?}
vroi[4] := 5; // ->{0,1,3,* length(2),5,?}
vroi[3] := 4; // ->{0,1,3,4,5,?}

var template RoI vroi := {1,*,5}
vroi[2] := 2; // this will produce an error as it tries to index  something which is covered by the '*'

RoI var template vroi := {1, *, 2};
vroi[1] := 1; // ok -> {1, 1, 2}

RoI var template vroi := {1, *, 2};
vroi := {10, -, 20 } // -> error, as index 2 crosses the index of '*' of  the original value
vroi := {-, 20} // ok -> {1, 20}
 
vroi := {1, permutation(10, 20), 2}
vroi := {11, -, -, 12} // -> ok as permutation elements remain untouched
vroi := {11, 12, - 12} // -> error: as not the whole permutation gets  overwritten
 
vroi := {11, 12}; // -> from 6.2.3 example 2 I would say it is allowed  and the result is {11, 12}, nevertheless index 1 is originally part of a  permutation and thus this should be an error.

RoI var template vroi := {1, 2, 3}
vroi := {*, -, 4};

var template RoI vroi1 := {1,2,3}
var template RoI vroi := {*,-,4} modifies vroi1;

var template RoI vroi := {1,2,3}
vroi := {-, 20}; // leads to this outcome: vroi == {1, 20}

var template RoI vroi := {1,2,3}
vroi := {-, *}; // would then lead to vroi == {1,*}

RoI var template vroi := {1, *, 2};
vroi[1] := 1; // ok -> {1, 1, 2}

RoI var template vroi := {1, *, 2};
vroi := {10, -, 20 } // -> error, as index 2 crosses the index of '*' of the original value
vroi := {-, 20} // ok -> {1, 20}
 
vroi := {1, permutation(10, 20), 2}
vroi := {11, -, -, 12} // -> ok as permutation elements remain untouched
vroi := {11, 12, - 12} // -> error: as not the whole permutation gets overwritten
 
vroi := {11, 12}; // -> from 6.2.3 example 2 I would say it is allowed 
                //and the result is {11, 12}, nevertheless index 1 is originally part 
                //of a permutation and thus this should be an error.

var template RoI vroi := {1, 2, 3};
vroi[1] := *;

var template RoI vroi := {1, 2, 3};
var template integer v_i := *;
vroi[1] := v_i;

template integer t_int := 1 ifpresent // is allowed
template MyRecord t_rec := { mandatoryField := 1, optionalField := t_int } // is allowed; actually, this is the purpose of allowing ifpresent for all types
match (t_int,1) // shall cause an error , t_int shall not contain *, omit or ifpresent, when used for matching (defined today).
 
template RecordOf t_recof := { ? ifpresent, 2, 3 } // is not forbidden today, but useless, as t_recof[0] on the right hand side of an assignment, if it references something that is omit, * or ifpresent, causes an error; so, CR 6016 should also forbid assigning it to a t_recof element, thus at least in some cases this problem would cause a compile time error instead of a runtime error.
match (t_recof, { ?, 2, 3 }) // causes an error, because a record of element shall not contain omit, * or ifpresent when used for matching (defined today).