[V] Хорош ли синтаксис языка программирования V?

Function List__Add(List__ rval_ret L, Type1 rval_ret R):{
            L+=R;
            Return L;
        }

Function TFn1(_Counter F):
    Return F+1;
.
 
Function TFn2(_Counter F):
    Return F+2;
.
 
Function TFn1_TFn1(_Counter Cond, (TFn1) fn1, (TFn1) fn2):
    If Cond:
        Return fn1;
    .
    Return fn2;
.
 
Function CallIf(_Counter Cond, F):
    Return TFn1_TFn1(Cond, TFn1, TFn2)(F);
.

Type T1(_Counter F):
.
 
_Counter Set(T1 it, _Counter F):
    *lOld=it.F;
    it.F=F;
    Return lOld;
.
 
Program Prog(): // начало исполнения
    T1 lT1;
    *lOld3=ret_Set(lT1, 2).ret_print_Set(3).print_Set(4);
// у функций появились префиксы вида "ret_" "print_"
    Print("lOld3="+lOld3.ToString+"\n");
    Print("lT1.F(4)="+lT1.F.ToString+"\n");
 
    End 0; // возврат кода завершения
.

_Counter Print(_String) <- _ОтобразитьСтроку;
_String ToString(_Text) <- _ВСтрокуТекст;
_String ToString(_Counter) <- _СчетчикВСтроку;
 
Type TFnBaseT(_String name):{
}
 
?Template TFnBaseExtT - Type1 FnType1(
    Function TFnBaseExtT(_String name, (FnType1) fn):{
        Return {
            Type TFnBaseExtT__ TFnBaseT+((FnType1) fn):{
            }
 
            (_String name, (FnType1) fn):
                TFnBaseExtT__ lTFnBaseExt__; 
                lTFnBaseExt__.name=name; lTFnBaseExt__.fn=fn;
                Return lTFnBaseExt__;
        }(name, fn);
    }
)
 
List LFnBaseT[TFnBaseT]:{
}
Var LFnBaseT gLFnBaseT;
 
?Template GetFn - Type2 FnType1(
    Function GetFn(_String name, (FnType1) fn)(gLFnBaseT):{
        *lForT=TFnBaseExtT(name, fn);
        @el,ind++ gLFnBaseT:
            If el.name==name:
                el._lForT_:
                    Print("Попалась "+name+"\n");
                    Return el.fn;
                .
            .
        .
        gLFnBaseT+=TFnBaseExtT(name, fn);
        Return fn;
    }
    Function GetFn(_Text name, (FnType1) fn):{
        Return GetFn(name.ToString, fn);
    }
)
 
?Template SetFn - Type2 FnType1(
    Function SetFn(_String name, (FnType1) fn)(gLFnBaseT):{
        *lForT=TFnBaseExtT(name, fn);
        @el,ind++ gLFnBaseT:
            If el.name==name:
                el._lForT_:
                    el.fn=fn;
                    Print("Попалась "+name+"\n");
                    Return 1;
                .
            .
        .
        gLFnBaseT+=TFnBaseExtT(name, fn);
        Return 0;
    }
    Function SetFn(_Text name, (FnType1) fn):{
        Return SetFn(name.ToString, fn);
    }
)
 
?Template CreateList - Type2(
    Function CreateList(Type2 t2):{
        Return {
            List List__[Type2]:.
 
            ():
                List__ lList__;
                =lList__;
        }();
    }
);
 
?Template GetFns - FnType1(
    Function GetFns((FnType1) fn)(gLFnBaseT):{
        _String name;
        *lForT=TFnBaseExtT(name, fn);
        *lRes=CreateList(lForT);
        @el,ind++ gLFnBaseT:
            el._lForT_:
                lRes+=TFnBaseExtT(el.name, el.fn);
                Print("Нашлась "+el.name+"\n");
            .
        .
        Return lRes;
    }
)
 
Program Prog(): // начало исполнения
 
    *fn1=GetFn"A2"{_Counter A:=A+A};
    *fn2=GetFn"A3"{_Counter A:=A+A};
    Print(fn1(10).ToString+"==20\n");
    SetFn"A2"{_Counter A:=A*A};
    fn1=GetFn"A2"{_Counter A:=A+A};
    Print(fn1(10).ToString+"==100\n");
    Print(GetFn("A2",fn1)(11).ToString+"==121\n");
 
    @lel,ind++ GetFns{_Counter A:=A}:
        Print(ind.ToString+") "+lel.name+"(3)="+lel.fn(3).ToString+"\n");
    .
 
    End 0; // возврат кода завершения
.