diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
index a424e37..702f5d0 100644
--- a/cpp/src/compilation/targetinterpretation.cpp
+++ b/cpp/src/compilation/targetinterpretation.cpp
@@ -1,495 +1,494 @@
 /*
  * File:   targetinterpretation.cpp
  * Author: pgess
  *
  * Created on June 29, 2016, 6:45 PM
  */
 
 #include "compilation/targetinterpretation.h"
 #include "pass/interpretationpass.h"
 #include "analysis/typeinference.h"
 #include "llvmlayer.h"
 #include "compilation/scopedecorators.h"
 
 #include <boost/scoped_ptr.hpp>
 #include <iostream>
 #include <clang/AST/DeclBase.h>
 
 using namespace std;
 using namespace xreate::compilation;
 
 namespace xreate{ namespace interpretation{
 
     const Expression EXPRESSION_FALSE = Expression(Atom<Number_t>(0));
     const Expression EXPRESSION_TRUE = Expression(Atom<Number_t>(1));
 
 //Expression
 //InterpretationScope::compile(const Expression& expression){}
 
 CodeScope*
 InterpretationScope::processOperatorIf(const Expression& expression){
     const Expression& exprCondition = process(expression.getOperands()[0]);
 
     if (exprCondition == EXPRESSION_TRUE){
         return expression.blocks.front();
     }
 
     return expression.blocks.back();
 }
 
 CodeScope*
 InterpretationScope::processOperatorSwitch(const Expression& expression) {
     const Expression& exprCondition = process(expression.operands[0]);
 
     bool flagHasDefault = expression.operands[1].op == Operator::CASE_DEFAULT;
 
     //TODO check that one and only one case variant is appropriate
     for (size_t size = expression.operands.size(), i= flagHasDefault? 2: 1; i<size; ++i){
         const Expression& exprCase = process(expression.operands[i]);
 
         if (function->getScope(exprCase.blocks.front())->processScope() == exprCondition){
             return exprCase.blocks.back();
         }
     }
 
     if (flagHasDefault){
         const Expression& exprCaseDefault = expression.operands[1];
         return exprCaseDefault.blocks.front();
     }
 
     assert(false && "Switch has no appropriate variant");
     return nullptr;
 }
 
 CodeScope*
 InterpretationScope::processOperatorSwitchVariant(const Expression& expression){
     const Expression& condition = process(expression.operands.at(0));
     assert(condition.op == Operator::VARIANT);
-    const string identCondition = expression.operands.at(0).getValueString();
-
+    const string identCondition = expression.bindings.front();
 
     Expression opExpected(Atom<Number_t>(condition.getValueDouble()));
     auto itFoundValue = std::find(++expression.operands.begin(), expression.operands.end(), opExpected);
     assert(itFoundValue != expression.operands.end());
 
     int indexBlock = itFoundValue - expression.operands.begin() -1;
     auto blockFound = expression.blocks.begin();
     std::advance(blockFound, indexBlock);
 
     InterpretationScope* scopeI12n = function->getScope(*blockFound);
 
     if (condition.operands.size()) {
         const Expression& value = condition.operands.at(0);
         scopeI12n->overrideBinding(value, identCondition);
     }
 
     return *blockFound;
 }
 
 llvm::Value*
 InterpretationScope::compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context){
     switch(op){
         case IF_INTERPRET_CONDITION: {
             CodeScope* scopeResult = processOperatorIf(expression);
 
             llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
             return result;
         }
 
         case SWITCH_INTERPRET_CONDITION:{
             CodeScope* scopeResult = processOperatorSwitch(expression);
 
             llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
             return result;
         }
 
         case SWITCH_VARIANT: {
             CodeScope* scopeResult = processOperatorSwitchVariant(expression);
             const Expression& condition = process(expression.operands.at(0));
 
-            const string identCondition = expression.operands.at(0).getValueString();
+            const string identCondition = expression.bindings.front();
             auto scopeCompilation = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeResult));
 
             if(condition.operands.size()){
                 //override value
                 Symbol symbCondition{ScopedSymbol{scopeResult->__identifiers.at(identCondition), versions::VERSION_NONE}, scopeResult};
                 scopeCompilation->overrideDeclaration(symbCondition, Expression(condition.operands.at(0)));
 
                 //set correct type for binding:
                 TypeAnnotation typeVariant = typeinference::getType(condition, *function->man->ast);
                 int conditionIndex = condition.getValueDouble();
                 ScopedSymbol symbolInternal = scopeResult->getSymbol(identCondition);
                 scopeResult->__declarations[symbolInternal].bindType(typeVariant.__operands.at(conditionIndex));
             }
 
             llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
             return result;
         }
 
         case FOLD_INTERPRET_INPUT: {
             //initialization
             const Expression& exprInput = process(expression.getOperands()[0]);
             assert(exprInput.op == Operator::LIST);
 
             CodeScope* scopeBody = expression.blocks.front();
 
             const string& nameEl = expression.bindings[0];
             Symbol symbEl{ScopedSymbol{scopeBody->__identifiers.at(nameEl), versions::VERSION_NONE}, scopeBody};
             const std::string& idAccum = expression.bindings[1];
             llvm::Value* rawAccum = context.scope->process(expression.getOperands()[1]);
 
             InterpretationScope* intrBody = function->getScope(scopeBody);
             auto unitBody = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeBody));
 
             const std::vector<Expression> elementsInput= exprInput.getOperands();
 
             for (size_t i=0; i<elementsInput.size(); ++i){
                 intrBody->reset();
                 unitBody->reset();
 
                 Expression exprElement  = elementsInput[i];
 
                 intrBody->overrideBinding(exprElement, nameEl);
                 unitBody->overrideDeclaration(symbEl, move(exprElement));
                 unitBody->bindArg(rawAccum, string(idAccum));
 
                 rawAccum = unitBody->compile();
             }
 
             return rawAccum;
         }
 
         /*
         case FOLD_INF_INTERPRET_INOUT{
         }
         */
 
         case CALL_INTERPRET_PARTIAL: {
             const std::string &calleeName = expression.getValueString();
             ICodeScopeUnit* scopeUnitSelf = context.scope;
             ManagedFnPtr callee = this->function->man->ast->findFunction(calleeName);
             const  FunctionInterpretationData& calleeData = FunctionInterpretationHelper::getSignature(callee);
             std::vector<llvm::Value *> argsActual;
             PIFSignature sig;
             sig.declaration = callee;
 
             for(size_t no=0, size = expression.operands.size(); no < size; ++no){
                 const Expression& op =  expression.operands[no];
 
                 if (calleeData.signature.at(no) == INTR_ONLY){
                     sig.bindings.push_back(process(op));
                     continue;
                 }
 
                 argsActual.push_back(scopeUnitSelf->process(op));
             }
 
             TargetInterpretation* man = dynamic_cast<TargetInterpretation*>(this->function->man);
             PIFunction* pifunction =  man->getFunction(move(sig));
 
             llvm::Function* raw = pifunction->compile();
             boost::scoped_ptr<CallStatementRaw> statement(new CallStatementRaw(raw, man->pass->man->llvm));
             return (*statement)(move(argsActual));
         }
 
         default: break;
     }
 
     assert(false&& "Unknown hybrid operator");
     return nullptr;
 }
 
 llvm::Value*
 InterpretationScope::compile(const Expression& expression, const Context& context){
     const InterpretationData& data = Attachments::get<InterpretationData>(expression);
 
     if (data.op != InterpretationOperator::NONE){
         return compileHybrid(data.op, expression, context);
     }
 
     Expression result = process(expression);
     return context.scope->process(result);
 }
 
 Expression
 InterpretationScope::process(const Expression& expression){
     switch (expression.__state){
         case Expression::INVALID:
             assert(false);
 
         case Expression::NUMBER:
         case Expression::STRING:
             return expression;
 
         case Expression::IDENT:{
             Symbol s = Attachments::get<Symbol>(expression);
             return Parent::processSymbol(s);
         }
 
         case Expression::COMPOUND:
             break;
 
         default: assert(false);
     }
 
     switch (expression.op) {
         case Operator::EQU: {
             const Expression& left = process(expression.operands[0]);
             const Expression& right = process(expression.operands[1]);
 
             if (left == right) return EXPRESSION_TRUE;
             return EXPRESSION_FALSE;
         }
 
         case Operator::NE: {
             const Expression& left = process(expression.operands[0]);
             const Expression& right = process(expression.operands[1]);
 
             if (left == right) return EXPRESSION_FALSE;
             return EXPRESSION_TRUE;
         }
 
         case Operator::LOGIC_AND: {
             assert(expression.operands.size() == 1);
             return process (expression.operands[0]);
         }
 
 
 //        case Operator::LOGIC_OR:
         case Operator::CALL: {
             const std::string &fnName = expression.getValueString();
             ManagedFnPtr fnAst = this->function->man->ast->findFunction(fnName);
             InterpretationFunction* fnUnit = this->function->man->getFunction(fnAst);
 
             vector<Expression> args;
             args.reserve(expression.getOperands().size());
 
             for(size_t i=0, size = expression.getOperands().size(); i<size; ++i) {
                 args.push_back(process(expression.getOperands()[i]));
             }
 
             return fnUnit->process(args);
         }
 
         case Operator::IF:{
             CodeScope* scopeResult = processOperatorIf(expression);
             return function->getScope(scopeResult)->processScope();
         }
 
         case Operator::SWITCH: {
             CodeScope* scopeResult = processOperatorSwitch(expression);
             return function->getScope(scopeResult)->processScope();
         }
 
         case Operator::SWITCH_VARIANT: {
             CodeScope* scopeResult = processOperatorSwitchVariant(expression);
             return function->getScope(scopeResult)->processScope();
         }
 
         case Operator::INDEX: {
             const Expression& exprKey = process(expression.operands[1]);
             const Expression& exprData = process(expression.operands[0]);
 
             if (exprKey.__state == Expression::STRING){
                 const string& key = exprKey.getValueString();
                 assert(exprData.__indexBindings.count(key));
 
                 return exprData.operands[exprData.__indexBindings.at(key)];
             }
 
             if (exprKey.__state == Expression::NUMBER){
                 int key = exprKey.getValueDouble();
                 return exprData.operands[key];
             }
 
             assert(false);
         }
 
         case Operator::FOLD: {
             const Expression& exprInput = process(expression.getOperands()[0]);
             const Expression& exprInit = process(expression.getOperands()[1]);
 
             const std::string& argEl = expression.bindings[0];
             const std::string& argAccum = expression.bindings[1];
 
             InterpretationScope* body = function->getScope(expression.blocks.front());
 
             Expression accum = exprInit;
             for(size_t size=exprInput.getOperands().size(), i=0; i<size; ++i){
                 body->overrideBinding(exprInput.getOperands()[i], argEl);
                 body->overrideBinding(accum, argAccum);
 
                 accum = body->processScope();
             }
 
             return accum;
         }
 
 //        case Operator::MAP: {
 //            break;
 //        }
 
         default: break;
     }
 
     return expression;
 }
 
 InterpretationFunction*
 TargetInterpretation::getFunction(IFunctionUnit* unit){
     if (__dictFunctionsByUnit.count(unit)) {
         return __dictFunctionsByUnit.at(unit);
     }
 
     InterpretationFunction* f = new InterpretationFunction(unit->function, this);
     __dictFunctionsByUnit.emplace(unit, f);
     assert(__functions.emplace(unit->function.id(), f).second);
 
     return f;
 }
 
 PIFunction*
 TargetInterpretation::getFunction(PIFSignature&& sig){
 
     auto f = __pifunctions.find(sig);
     if (f != __pifunctions.end()){
         return f->second;
     }
 
     PIFunction* result  = new PIFunction(PIFSignature(sig), __pifunctions.size(), this);
     __pifunctions.emplace(move(sig), result);
     assert(__dictFunctionsByUnit.emplace(result->functionUnit, result).second);
 
     return result;
 }
 
 InterpretationScope*
 TargetInterpretation::transformContext(const Context& c){
     return this->getFunction(c.function)->getScope(c.scope->scope);
 }
 
 llvm::Value*
 TargetInterpretation::compile(const Expression& expression, const Context& ctx){
     return transformContext(ctx)->compile(expression, ctx);
 }
 
 InterpretationFunction::InterpretationFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target)
     : Function<TargetInterpretation>(function, target)
 {}
 
 Expression
 InterpretationFunction::process(const std::vector<Expression>& args){
     InterpretationScope* body = getScope(__function->__entry);
 
     for(size_t i=0, size = args.size(); i<size; ++i) {
         body->overrideBinding(args.at(i), string(body->scope->__bindings.at(i)));
     }
 
     return body->processScope();
 }
 
 //                  Partial function interpretation
 
 typedef BasicFunctionUnit PIFunctionUnitParent;
 class PIFunctionUnit: public PIFunctionUnitParent{
 public:
 
     PIFunctionUnit(ManagedFnPtr f, std::set<size_t>&& arguments, size_t id, CompilePass* p)
         : PIFunctionUnitParent(f,  p), argumentsActual(move(arguments)), __id(id)
     {}
 
 protected:
     std::vector<llvm::Type*> prepareArguments(){
         LLVMLayer* llvm = PIFunctionUnitParent::pass->man->llvm;
         AST* ast = PIFunctionUnitParent::pass->man->root;
         CodeScope* entry = PIFunctionUnitParent::function->__entry;
         std::vector<llvm::Type*> signature;
 
         for(size_t no: argumentsActual){
             VNameId argId = entry->__identifiers.at(entry->__bindings.at(no));
             ScopedSymbol arg{argId, versions::VERSION_NONE};
 
             signature.push_back(llvm->toLLVMType(ast->expandType(entry->__declarations.at(arg).type)));
         }
 
         return signature;
     }
 
     llvm::Function::arg_iterator prepareBindings(){
         CodeScope* entry = PIFunctionUnitParent::function->__entry;
         ICodeScopeUnit* entryCompilation = PIFunctionUnitParent::getScopeUnit(entry);
         llvm::Function::arg_iterator fargsI = PIFunctionUnitParent::raw->arg_begin();
 
         for(size_t no: argumentsActual){
             ScopedSymbol arg{entry->__identifiers.at(entry->__bindings.at(no)), versions::VERSION_NONE};
 
             entryCompilation->bindArg(&*fargsI, arg);
             fargsI->setName(entry->__bindings.at(no));
             ++fargsI;
         }
 
         return fargsI;
     }
 
     virtual std::string prepareName(){
         return PIFunctionUnitParent::prepareName() + "_" + std::to_string(__id);
     }
 
 private:
     std::set<size_t> argumentsActual;
     size_t __id;
 };
 
 PIFunction::PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target)
     : InterpretationFunction(sig.declaration, target), signatureInstance(move(sig))
 {
     const FunctionInterpretationData&  functionData = FunctionInterpretationHelper::getSignature(signatureInstance.declaration);
 
     std::set<size_t> argumentsActual;
     for (size_t no=0, size=functionData.signature.size(); no < size; ++no){
         if (functionData.signature.at(no) != INTR_ONLY){
             argumentsActual.insert(no);
         }
     }
 
     functionUnit = new PIFunctionUnit(signatureInstance.declaration, move(argumentsActual), id, target->pass);
     CodeScope* entry = signatureInstance.declaration->__entry;
     auto entryUnit = Decorators<CachedScopeDecoratorTag>::getInterface<>(functionUnit->getEntry());
     InterpretationScope* entryIntrp = InterpretationFunction::getScope(entry);
 
     for(size_t no=0, sigNo=0, size = entry->__bindings.size(); no < size; ++no){
         if (functionData.signature.at(no) == INTR_ONLY){
             entryIntrp->overrideBinding(signatureInstance.bindings[sigNo], entry->__bindings[no]);
 
             VNameId argId = entry->__identifiers.at(entry->__bindings[no]);
             Symbol argSymbol{ScopedSymbol{argId, versions::VERSION_NONE}, entry};
             entryUnit->overrideDeclaration(argSymbol, Expression(signatureInstance.bindings[sigNo]));
             ++sigNo;
         }
     }
 }
 
 llvm::Function*
 PIFunction::compile(){
     llvm::Function* raw = functionUnit->compile();
 
     return raw;
 }
 
 bool operator<(const PIFSignature& lhs, const PIFSignature& rhs){
     if (lhs.declaration.id() != rhs.declaration.id()) {
         return lhs.declaration.id() < rhs.declaration.id();
     }
 
     return lhs.bindings < rhs.bindings;
 }
 
 bool operator<(const PIFSignature& lhs, PIFunction* const rhs){
     return lhs < rhs->signatureInstance;
 }
 
 bool operator<(PIFunction* const lhs, const PIFSignature& rhs){
     return lhs->signatureInstance < rhs;
 }
 
 }}
diff --git a/cpp/src/pass/interpretationpass.cpp b/cpp/src/pass/interpretationpass.cpp
index 09e7ac4..6fd6cfd 100644
--- a/cpp/src/pass/interpretationpass.cpp
+++ b/cpp/src/pass/interpretationpass.cpp
@@ -1,448 +1,448 @@
 /*
  * File:   interpretationpass.cpp
  * Author: pgess
  *
  * Created on July 5, 2016, 5:21 PM
  */
 
 #include "pass/interpretationpass.h"
 //#include "compilation/transformations.h"
 #include <compilation/targetinterpretation.h>
 #include <bits/stl_vector.h>
 #include "ast.h"
 //DEBT implement InterpretationPass purely in clasp
 //DEBT represent InterpretationPass as general type inference
 
 using namespace std;
 
 namespace xreate{
 
 template<>
 interpretation::InterpretationResolution
 defaultValue<interpretation::InterpretationResolution>(){
     return interpretation::CMPL_ONLY;
 }
 
 namespace interpretation{
 enum InterpretationQuery{QUERY_INTR_ONLY, QUERY_CMPL_ONLY};
 
 namespace details {
     template<InterpretationQuery FLAG_REQUIRED>
     bool checkConstraints(InterpretationResolution flag) {
         return (   (flag==INTR_ONLY && FLAG_REQUIRED == QUERY_INTR_ONLY)
                 || (flag==CMPL_ONLY && FLAG_REQUIRED == QUERY_CMPL_ONLY));
     }
 
     InterpretationResolution
     recognizeTags(const map<std::string, Expression>& tags){
         auto i = tags.find("interpretation");
         if (i== tags.end()){
             return ANY;
         }
 
         assert(i->second.op == Operator::CALL);
         const string& cmd = i->second.operands.at(0).getValueString();
 
         //TODO make consistent names  of annotation and resolution
         if        (cmd == "force"){
             return INTR_ONLY;
 
         } else if (cmd == "suppress"){
             return CMPL_ONLY;
         }
 
         return ANY;
     }
 }
 
 InterpretationResolution
 unify(InterpretationResolution flag) {
     return flag;
 }
 
 template<typename FLAG_A, typename FLAG_B, typename... FLAGS>
 InterpretationResolution
 unify(FLAG_A flagA, FLAG_B flagB, FLAGS... flags) {
 
     if (flagA== ANY){
         return unify(flagB, flags...);
     }
 
     if (flagB == ANY) {
         return unify(flagA, flags...);
     }
 
     assert(flagA == flagB);
     return flagA;
 }
 
 template<InterpretationQuery FLAG_REQUIRED>
 bool checkConstraints(std::vector<InterpretationResolution>&& flags) {
     assert(flags.size());
 
     InterpretationResolution flag = flags.front();
     return details::checkConstraints<FLAG_REQUIRED>(flag);
 }
 
 template<InterpretationQuery FLAG_REQUIRED_A, InterpretationQuery FLAG_REQUIRED_B, InterpretationQuery... FLAGS>
 bool checkConstraints(std::vector<InterpretationResolution>&& flags) {
     assert(flags.size());
 
     InterpretationResolution flag = flags.front();
     flags.pop_back();
 
     if (details::checkConstraints<FLAG_REQUIRED_A>(flag)){
         return checkConstraints<FLAG_REQUIRED_B, FLAGS...>(move(flags));
     }
 
     return false;
 }
 
 bool
 InterpretationData::isDefault() const{
     return (resolution == ANY && op == NONE);
 }
 
 void
 recognizeTags(const Expression& e){
     InterpretationData tag{details::recognizeTags(e.tags), NONE};
     if (!tag.isDefault())
         Attachments::put<InterpretationData>(e, tag);
 }
 
 InterpretationResolution
 recognizeTags(const ManagedFnPtr& f){
     return details::recognizeTags(f->getTags());
 }
 
 InterpretationPass::InterpretationPass(PassManager* manager)
     : AbstractPass(manager) {
 
     Attachments::init<FunctionInterpretationData>();
     Attachments::init<InterpretationData>();
 }
 
 void InterpretationPass::run(){
     ManagedFnPtr f = man->root->begin<Function>();
     auto& visitedSymbols = getSymbolCache();
 
     while (f.isValid()) {
         const Symbol& symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};
 
         if (!visitedSymbols.isCached(symbolFunction)){
             visitedSymbols.setCachedValue(symbolFunction, process(f));
         }
 
         ++f;
     }
 }
 
 InterpretationResolution
 InterpretationPass::process(const Expression& expression, PassContext context, const std::string& decl){
     recognizeTags(expression);
 
     InterpretationResolution resolution = ANY;
     InterpretationOperator op = NONE;
 
     switch (expression.__state){
 
         case Expression::NUMBER:
         case Expression::STRING: {
             break;
         }
 
         case Expression::IDENT: {
             resolution = Parent::processSymbol(Attachments::get<Symbol>(expression), context);
             break;
         }
 
         case Expression::COMPOUND:
             break;
 
         default: { resolution = CMPL_ONLY; break;}
     }
 
     if (expression.__state == Expression::COMPOUND)
     switch(expression.op){
         case Operator::EQU:
         case Operator::NE: {
             InterpretationResolution left =  process(expression.operands[0], context);
             InterpretationResolution right = process(expression.operands[1], context);
 
             resolution = unify(left, right);
             break;
         }
 
         case Operator::LOGIC_AND: {
             assert(expression.operands.size() == 1);
             resolution = process (expression.operands[0], context);
             break;
         }
 
         case Operator::CALL: {
             //TODO cope with static/dynamic context
             //TODO BUG here: if several variants they all are processed as CMPL careless of signature
             list<ManagedFnPtr> callees = man->root->getFunctionVariants(expression.getValueString());
             if (callees.size()!=1){
                 resolution = CMPL_ONLY;
                 break;
             }
 
             ManagedFnPtr callee = callees.front();
             const Symbol& symbCalleeFunc{ScopedSymbol::RetSymbol, callee->getEntryScope()};
 
             //recursion-aware processing:
             //  - skip self recursion
             const Symbol& symbSelfFunc{ScopedSymbol::RetSymbol, context.function->getEntryScope()};
             if (!(symbSelfFunc == symbCalleeFunc)){
                 InterpretationResolution resCallee = processFnCall(callee, context);
                 assert(resCallee != FUNC_POSTPONED && "Indirect recursion detected: can't decide on interpretation resolution");
 
                 resolution = unify(resolution, resCallee);
             }
 
             //check arguments compatibility
             const FunctionInterpretationData& calleeSignature = FunctionInterpretationHelper::getSignature(callee);
             for (size_t op=0, size = expression.operands.size(); op < size; ++op){
                 const Expression &operand = expression.operands[op];
                 InterpretationResolution argActual =  process(operand, context);
                 InterpretationResolution argExpected =  calleeSignature.signature[op];
 
                 //TODO use args unification result to properly process function call
                 unify(argActual, argExpected);
             }
 
             if (FunctionInterpretationHelper::needPartialInterpretation(callee)){
                 op= CALL_INTERPRET_PARTIAL;
             }
 
             break;
         }
 
         case Operator::IF:{
             InterpretationResolution flagCondition = process(expression.getOperands()[0], context);
             InterpretationResolution flagScope1 = Parent::process(expression.blocks.front(), context);
             InterpretationResolution flagScope2 = Parent::process(expression.blocks.back(), context);
 
             //special case: IF_INTERPRET_CONDITION
             if (checkConstraints<QUERY_INTR_ONLY>({flagCondition})){
                 op= IF_INTERPRET_CONDITION;
                 flagCondition = ANY;
             }
 
             resolution = unify(flagCondition, flagScope1, flagScope2);
             break;
         }
 
         case Operator::FOLD: {
             InterpretationResolution flagInput = process(expression.getOperands()[0], context);
             InterpretationResolution flagAccumInit = process(expression.getOperands()[1], context);
 
             CodeScope* scopeBody = expression.blocks.front();
             const std::string& nameEl = expression.bindings[0];
             Symbol symbEl{ScopedSymbol{scopeBody->__identifiers.at(nameEl), versions::VERSION_NONE}, scopeBody};
             getSymbolCache().setCachedValue(symbEl, InterpretationResolution(flagInput));
 
             const std::string& nameAccum = expression.bindings[1];
             Symbol symbAccum{ScopedSymbol{scopeBody->__identifiers.at(nameAccum), versions::VERSION_NONE}, scopeBody};
             getSymbolCache().setCachedValue(symbAccum, InterpretationResolution(flagAccumInit));
 
             InterpretationResolution flagBody = Parent::process(expression.blocks.front(), context);
 
             //special case: FOLD_INTERPRET_INPUT
             if (checkConstraints<QUERY_INTR_ONLY>({flagInput})){
                 op= FOLD_INTERPRET_INPUT;
                 flagInput = ANY;
             }
 
             resolution = unify(flagInput, flagAccumInit, flagBody);
             break;
         }
 
         case Operator::INDEX: {
             resolution = unify(
                 process(expression.operands[0], context),
                 process(expression.operands[1], context)
             );
 
             break;
         }
 
         case Operator::SWITCH: {
             InterpretationResolution flagCondition = process(expression.operands[0], context);
             bool hasDefaultCase = expression.operands[1].op == Operator::CASE_DEFAULT;
 
 
             //determine conditions resolution
             InterpretationResolution flagHeaders = flagCondition;
             for (size_t size = expression.operands.size(), i= hasDefaultCase? 2: 1; i<size; ++i){
                 const Expression& exprCase = expression.operands[i];
 
                 flagHeaders = unify(flagHeaders, Parent::process(exprCase.blocks.front(), context));
             }
 
             if (checkConstraints<QUERY_INTR_ONLY>({flagHeaders})){
                 op= SWITCH_INTERPRET_CONDITION;
                 flagHeaders = ANY;
             }
 
             //determine body resolutions
             resolution = flagHeaders;
             for (size_t size = expression.operands.size(), i= 1; i<size; ++i){
                 const Expression& exprCase = expression.operands[i];
 
                 resolution = unify(resolution, Parent::process(exprCase.blocks.back(), context));
             }
 
             break;
         }
 
         case Operator::SWITCH_VARIANT: {
             InterpretationResolution resolutionCondition = process(expression.operands.at(0), context);
             resolution= resolutionCondition;
 
             if (checkConstraints<QUERY_INTR_ONLY>({resolution})){
                 op= SWITCH_VARIANT;
                 resolution = ANY;
             }
 
-            const string identCondition = expression.operands.at(0).getValueString();
+            const string identCondition = expression.bindings.front();
             for(auto scope: expression.blocks){
                 //set binding resolution
                 ScopedSymbol symbolInternal = scope->getSymbol(identCondition);
                 getSymbolCache().setCachedValue(Symbol{symbolInternal, scope}, InterpretationResolution(resolutionCondition));
 
                 resolution = unify(resolution, Parent::process(scope, context));
             }
 
             for(auto scope: expression.blocks){
                 resolution = unify(resolution, Parent::process(scope, context));
             }
             break;
         }
 
         case Operator::LIST:
         case Operator::LIST_NAMED: {
             for (const Expression &op: expression.getOperands()) {
                 resolution = unify(resolution, process(op, context));
             }
 
             break;
         }
 
         case Operator::VARIANT: {
             if(expression.getOperands().size()){
                 resolution = process(expression.getOperands().front(), context);
             } else {
                 resolution = ANY;
             }
 
             break;
         }
 
         default: {
             resolution = CMPL_ONLY;
 
             for (const Expression &op: expression.getOperands()) {
                 process(op, context);
             }
 
             for (CodeScope* scope: expression.blocks) {
                 Parent::process(scope, context);
             }
 
             break;
         }
     }
 
     InterpretationResolution resolutionExpected =
             Attachments::get<InterpretationData>(expression, {ANY, NONE}).resolution;
 
     resolution = unify(resolution, resolutionExpected);
     if (resolution != resolutionExpected && (op!=NONE || resolution == INTR_ONLY)){
         Attachments::put<InterpretationData>(expression, {resolution, op});
     }
 
     return resolution;
 }
 
     InterpretationResolution
     InterpretationPass::processFnCall(ManagedFnPtr function, PassContext context){
         return process(function);
     }
 
     InterpretationResolution
     InterpretationPass::process(ManagedFnPtr function){
         CodeScope* entry = function->getEntryScope();
         std::vector<std::string> arguments = entry->__bindings;
         const Symbol& symbSelfFunc{ScopedSymbol::RetSymbol, function->getEntryScope()};
         auto& cache = getSymbolCache();
 
         if (cache.isCached(symbSelfFunc))
             return cache.getCachedValue(symbSelfFunc);
 
         const FunctionInterpretationData& fnSignature = FunctionInterpretationHelper::getSignature(function);
         InterpretationResolution fnResolutionExpected = details::recognizeTags(function->getTags());
 
         //mark preliminary function resolution as expected
         if (fnResolutionExpected != ANY){
             cache.setCachedValue(symbSelfFunc, move(fnResolutionExpected));
 
         } else {
             //  - in order to recognize indirect recursion mark this function resolution as POSTPONED
             cache.setCachedValue(symbSelfFunc, FUNC_POSTPONED);
         }
 
         //set resolution for function arguments as expected
         for (int argNo = 0, size = arguments.size(); argNo< size; ++argNo){
             Symbol symbArg{ScopedSymbol{entry->__identifiers.at(arguments[argNo]), versions::VERSION_NONE}, entry};
             cache.setCachedValue(symbArg, InterpretationResolution(fnSignature.signature[argNo]));
         }
 
         PassContext context;
         context.function = function;
         context.scope = entry;
         InterpretationResolution resActual  = process(CodeScope::getDeclaration(symbSelfFunc), context);
         resActual =  unify(resActual, fnResolutionExpected);
         return cache.setCachedValue(symbSelfFunc, move(resActual));
     }
 
     const FunctionInterpretationData
     FunctionInterpretationHelper::getSignature(ManagedFnPtr function){
         if (Attachments::exists<FunctionInterpretationData>(function)){
             return Attachments::get<FunctionInterpretationData>(function);
         }
 
         FunctionInterpretationData&& data = recognizeSignature(function);
         Attachments::put<FunctionInterpretationData>(function, data);
         return data;
     }
 
     FunctionInterpretationData
     FunctionInterpretationHelper::recognizeSignature(ManagedFnPtr function){
         CodeScope* entry = function->__entry;
         FunctionInterpretationData result;
         result.signature.reserve(entry->__bindings.size());
 
         bool flagPartialInterpretation = false;
         for(size_t no=0, size=entry->__bindings.size(); no < size; ++no){
             const std::string& argName = entry->__bindings[no];
             Symbol symbArg{ScopedSymbol{entry->__identifiers.at(argName), versions::VERSION_NONE}, entry};
 
             const Expression& arg = CodeScope::getDeclaration(symbArg);
 
             InterpretationResolution argResolution = details::recognizeTags(arg.tags);
             flagPartialInterpretation |= (argResolution == INTR_ONLY);
 
             result.signature.push_back(argResolution);
         }
         result.flagPartialInterpretation = flagPartialInterpretation;
         return result;
     }
 
     bool FunctionInterpretationHelper::needPartialInterpretation(ManagedFnPtr function){
         const FunctionInterpretationData& data = getSignature(function);
         return data.flagPartialInterpretation;
     }
 }} //end of namespace xreate::interpretation
 
diff --git a/cpp/tests/interpretation.cpp b/cpp/tests/interpretation.cpp
index 5cc7e99..1c1feb4 100644
--- a/cpp/tests/interpretation.cpp
+++ b/cpp/tests/interpretation.cpp
@@ -1,411 +1,438 @@
 #include "attachments.h"
 
 using namespace xreate;
 
 #include "xreatemanager.h"
 #include "compilation/targetinterpretation.h"
 
 #include "gtest/gtest.h"
 #include "boost/scoped_ptr.hpp"
 
 //#define FRIENDS_INTERPRETATION_TESTS               \
 //    friend class ::Modules_AST2_Test;       \
 //    friend class ::Modules_Discovery1_Test; \
 //    friend class ::Modules_Solve1_Test;
 
 #include "pass/interpretationpass.h"
 
 using namespace xreate::grammar::main;
 using namespace xreate::interpretation;
 
 TEST(Interpretation, Analysis_StatementIF_1){
     XreateManager* man = XreateManager::prepare(
 
 R"Code(
     main = function::bool {
         x = "a":: string.
 
         y = if (x=="b"):: bool; interpretation(force) {
             true
 
         } else {
             false
         }.
 
         y
     }
 )Code"          );
 
     InterpretationPass* pass = new InterpretationPass(man);
     pass->run();
 
     CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
     Symbol symbolY{scopeEntry->getSymbol("y"), scopeEntry};
     InterpretationData& dataSymbolY = Attachments::get<InterpretationData>(symbolY);
 
     ASSERT_EQ(INTR_ONLY, dataSymbolY.resolution);
 }
 
 TEST(Interpretation, Compilation_StatementIF_1){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 
 R"Code(
     main = function::int; entry {
         x = "a":: string.
 
         y = if (x=="b"):: string; interpretation(force) {
             1
 
         } else {
             0
         }.
 
         y
     }
 )Code"          );
 
     man->analyse();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(0, result);
 }
 
 TEST(Interpretation, Analysis_StatementIF_InterpretCondition_1){
     XreateManager* man = XreateManager::prepare(
 
 R"Code(
     main = function(x:: int):: int {
         comm= "inc":: string; interpretation(force).
 
         y = if (comm == "inc")::int {x+1} else {x}.
         y
     }
 )Code" );
 
     InterpretationPass* pass = new InterpretationPass(man);
     pass->run();
 
     CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
     Symbol symbolY{scopeEntry->getSymbol("y"), scopeEntry};
     InterpretationData& dataSymbolY = Attachments::get<InterpretationData>(symbolY);
 
     ASSERT_EQ(CMPL_ONLY, dataSymbolY.resolution);
     ASSERT_EQ(IF_INTERPRET_CONDITION, dataSymbolY.op);
 }
 
 TEST(Interpretation, Compilation_StatementIF_InterpretCondition_1){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 
 R"Code(
     main = function(x:: int):: int; entry {
         comm= "inc":: string; interpretation(force).
 
         y = if (comm == "inc")::int {x+1} else {x}.
         y
     }
 )Code"          );
 
     man->analyse();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)(int) = (int (*)(int))man->run();
     int result = main(1);
 
     ASSERT_EQ(2, result);
 }
 
 TEST(Interpretation, Compilation_StatementFOLD_INTERPRET_INPUT_1){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 
 R"Code(
     main = function(x:: int):: int; entry {
         commands = ["inc", "double", "dec"]:: [string]; interpretation(force).
 
         loop fold(commands->comm::string, x->operand):: int{
             switch(comm)::int
 
             case ("inc"){
                 operand + 1
             }
 
             case ("dec"){
                 operand - 1
             }
 
             case ("double"){
                 operand * 2
             }
         }
     }
 )Code"          );
 
     man->analyse();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     const ManagedFnPtr& funcMain = man->root->findFunction("main");
     InterpretationData& dataBody = Attachments::get<InterpretationData>(funcMain);
     ASSERT_EQ(FOLD_INTERPRET_INPUT, dataBody.op);
 
     int (*main)(int) = (int (*)(int))man->run();
     int result = main(10);
 
     ASSERT_EQ(21, result);
 }
 
 TEST(Interpretation, StatementCall_RecursionNo_1){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 R"Code(
     unwrap = function(data::undef, keys::undef):: undef; interpretation(force){
         loop fold(keys->key::string, data->a):: undef {
            a[key]
         }
     }
 
     start = function::num; entry{
         result = unwrap(
             {
                 a = {
                         b =
                         {
                             c = "core"
                         }
                     }
             }, ["a", "b", "c"])::undef.
 
         result == "core"
     }
 )Code" );
 
     man->analyse();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(1, result);
 }
 
 TEST(Interpretation, StatementCall_RecursionDirect_1){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 R"Code(
     unwrap = function(data:: X):: Y {
         if (data[0] == "a")::Y {0} else {unwrap(data[0])}
     }
 
     entry = function:: i8; entry {
         unwrap([[[["a"]]]]):: i8; interpretation(force)
     }
 )Code" );
 
     man->analyse();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     InterpretationResolution resolutionActual = pass->process(man->root->findFunction("unwrap"));
     ASSERT_EQ(ANY, resolutionActual);
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(0, result);
 }
 
 TEST(Interpretation, StatementCall_RecursionIndirect_1){
         XreateManager* man = XreateManager::prepare(
 R"Code(
     funcA = function(data:: X):: Y {
         if (data == "a")::Y {0} else {funcB(data)}
     }
 
     funcB = function(data:: X):: Y {
         if (data == "b")::Y {1} else {funcA(data)}
     }
 
     entry = function:: i8; entry {
         funcA(""):: i8; interpretation(force)
     }
 )Code" );
 
     InterpretationPass* pass = new InterpretationPass(man);
     ASSERT_DEATH(pass->run(), "Indirect recursion detected");
 }
 
 TEST(Interpretation, PartialIntr_1){
     XreateManager* man = XreateManager::prepare(
 R"Code(
     evaluate= function(argument:: num, code:: string; interpretation(force)):: num {
         switch(code)::int
          case ("inc")    {argument + 1}
          case ("dec")    {argument - 1}
          case ("double") {argument * 2}
     }
 
     main = function::int; entry {
         commands= ["inc", "double", "dec"]:: [string]; interpretation(force).
 
         loop fold(commands->comm::string, 10->operand):: int{
             evaluate(operand, comm)
         }
     }
 )Code" );
 
     InterpretationPass* pass = new InterpretationPass(man);
     pass->run();
 
     ManagedFnPtr fnEvaluate = man->root->findFunction("evaluate");
     InterpretationResolution resFnEvaluate= pass->process(fnEvaluate);
     ASSERT_EQ(CMPL_ONLY, resFnEvaluate);
     ASSERT_TRUE(FunctionInterpretationHelper::needPartialInterpretation(fnEvaluate));
 
     const Expression& exprLoop = man->root->findFunction("main")->__entry->getBody();
     Symbol symbCallEv{{0, versions::VERSION_NONE}, exprLoop.blocks.front()};
     InterpretationData dataCallEv = Attachments::get<InterpretationData>(symbCallEv);
     ASSERT_EQ(CMPL_ONLY, dataCallEv.resolution);
     ASSERT_EQ(CALL_INTERPRET_PARTIAL, dataCallEv.op);
 }
 
 TEST(Interpretation, Compilation_PartialIntr_2){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 R"Code(
     evaluate= function(argument:: num, code:: string; interpretation(force)):: num {
         switch(code)::int
         case ("inc")    {argument + 1}
         case ("dec")    {argument - 1}
         case ("double") {argument * 2}
         case default {argument}
     }
 
     main = function::int; entry {
         commands= ["inc", "double", "dec"]:: [string]; interpretation(force).
 
         loop fold(commands->comm::string, 10->operand):: int{
             evaluate(operand, comm)
         }
     }
 )Code" );
 
     man->analyse();
     if (!man->isPassRegistered(PassId::InterpretationPass)){
         InterpretationPass* pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(21, result);
 }
 
 TEST(Interpretation, PartialIntr_3){
     xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
 R"Code(
     Command= type variant {INC, DEC, DOUBLE}.
 
     evaluate= function(argument:: num, code:: Command; interpretation(force)):: num {
         switch variant(code)::int
         case (INC)    {argument + 1}
         case (DEC)    {argument - 1}
         case (DOUBLE) {argument * 2}
     }
 
     main = function::int; entry {
         commands= [INC(), DOUBLE(), DEC()]:: [Command]; interpretation(force).
 
         loop fold(commands->comm::Command, 10->operand):: int{
             evaluate(operand, comm)
         }
     }
 )Code" );
 
     man->analyse();
     if (!man->isPassRegistered(PassId::InterpretationPass)){
         InterpretationPass* pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(21, result);
 }
 
 TEST(Interpretation, SwitchVariant){
     xreate::XreateManager* man = xreate::XreateManager::prepare(
 R"Code(
 OneArgument = type{x::int}.
 TWoArgument = type {x::int, y::int}.
 
 Command= type variant {
         ADD::TwoArguments,
         DEC:: OneArgument,
         DOUBLE::OneArgument
 }.
 
 main = function::int; entry{
     program = ADD({x=2, y=3})::Command; interpretation(force).
 
     switch variant(program)::int
         case (ADD) {program["x"]+program["y"]}
         case (DEC) {1}
         case (DOUBLE) {2}
 }
 )Code" );
 
     int (*main)() = (int (*)())man->run();
     int result = main();
     ASSERT_EQ(5, result);
 
 }
 
+TEST(Interpretation, SwitchVariantAlias){
+    xreate::XreateManager* man = xreate::XreateManager::prepare(
+R"Code(
+OneArgument = type{x::int}.
+TWoArgument = type {x::int, y::int}.
+
+Command= type variant {
+        ADD::TwoArguments,
+        DEC:: OneArgument,
+        DOUBLE::OneArgument
+}.
+
+main = function::int; entry{
+    program = [ADD({x=2, y=3}), DEC({x=8})]::Command; interpretation(force).
+
+    switch variant(program[0]->program)::int
+        case (ADD) {program["x"]+program["y"]}
+        case (DEC) {1}
+        case (DOUBLE) {2}
+}
+)Code" );
+
+    int (*main)() = (int (*)())man->run();
+    int result = main();
+    ASSERT_EQ(5, result);
+}
+
 TEST(InterpretationExamples, Regexp1){
     FILE* input = fopen("scripts/dsl/regexp.xreate","r");
     assert(input != nullptr);
 
     std::unique_ptr<XreateManager> man(XreateManager::prepare(input));
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(4, result);
 }
 
 //TOTEST call indirect recursion(w/o tags)
 //TASk implement and test Loop Inf (fix acc types in coco grammar)
diff --git a/grammar/xreate.ATG b/grammar/xreate.ATG
index 11b2fa1..f534db7 100644
--- a/grammar/xreate.ATG
+++ b/grammar/xreate.ATG
@@ -1,639 +1,653 @@
 //TODO add ListLiteral
 //TODO ExprTyped:  assign default(none) type
 
 #include "ast.h"
 #include "ExternLayer.h"
 #include "pass/adhocpass.h"
 #include <string>
 #include <stack>
 
 #define wprintf(format, ...) \
                 char __buffer[100];    \
                 wcstombs(__buffer, format, 100);   \
                 fprintf(stderr, __buffer, __VA_ARGS__)
                 
 using namespace std;
 
 COMPILER Xreate
 
  details::incomplete::AST* root = nullptr;  // current program unit 
  
  void ensureInitalizedAST(){
    if (root == nullptr) root = new details::incomplete::AST();
  }
  
  struct {
     std::stack<CodeScope*> scopesOld;
     CodeScope* scope = nullptr;
  } context;
  
  void pushContextScope(CodeScope* scope){
     context.scopesOld.push(context.scope);
     context.scope = scope;
  }
  
  void popContextScope(){
         context.scope = context.scopesOld.top();
         context.scopesOld.pop();
  }
      
 int nextToken()
 {
   scanner->ResetPeek();
   return scanner->Peek()->kind;
 }
 
 bool checkTokenAfterIdent(int key){
   if (la->kind != _ident) return false;
   return  nextToken()  == key;
 }
 
 bool checkParametersList()
 {
     return la->kind == _ident && nextToken() == _lparen;
 }
 
 bool checkInfix()
 {
   return la->kind == _ident && nextToken() == _ident;
 }
 
 bool checkIndex()
 {
   return la->kind == _ident && nextToken()  == _lbrack;
 }
 
 bool checkFuncDecl()
 {
   if (la->kind != _ident) return false;
   
   int token2 = nextToken();
   int token3 = scanner->Peek()->kind;
   
   return  token2  == _assign && (token3 == _function || token3 == _pre);
 }
 
 
 
 bool checkAssignment()
 {
   if (la->kind != _ident) return false;
   
   scanner->ResetPeek();
   int token2 = scanner->Peek()->kind;
   if (token2 == _lcurbrack) {
       scanner->Peek();
       int token3 = scanner->Peek()->kind;
       if (token3 != _rcurbrack) return false;
       
       int token4 = scanner->Peek()->kind;
       return token4 == _assign;
   }
   
   return  token2  == _assign;
 }
 
 void recognizeIdentifier(Expression& i){
     if (!context.scope->recognizeIdentifier(i)){       
         root->postponeIdentifier(context.scope, i);
     }
 }
 
 enum SwitchKind{SWITCH_NORMAL, SWITCH_META};
 
 CHARACTERS
   letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
   any = ANY - '"'.
   digit = "0123456789".
   cr  = '\r'.
   lf  = '\n'.
   tab = '\t'.
 
 TOKENS
   ident = (letter | '_') {letter | digit | '_'}.
   number = (digit | '-' digit) {digit}.
   string = '"' { any } '"'.
   function = "function".
   pre =  "pre".  
   lparen = '('. 
   rparen = ')'.
   lbrack = '['.
   rbrack = ']'.
   lcurbrack = '{'.
   rcurbrack = '}'.
   equal = "==".
   assign = '='.
   implic = '-' '>'.
   colon = ':'.
   context = "context".
   tagcolon   = "::".
   lse = "<=".
   lss = "<".
   gte = ">=".
   gtr = ">".
   
   ne1 = "!=".
   ne2= "<>".
   
 
 COMMENTS FROM "/*" TO "*/" NESTED
 COMMENTS FROM "//" TO lf
 
 IGNORE cr + lf + tab
 
 PRODUCTIONS
 
 Xreate =    (. Function* function; ensureInitalizedAST(); .)
 {(  RuleDecl 
     | InterfaceData | Imprt | ContextSection 
     | IF(checkFuncDecl()) FDecl<function>  (. root->add(function); .)
     | TDecl 
     | SkipModulesSection
 )}                                         (.  .)
 .
 
 Ident<std::wstring& name>
 = ident                                     (. name = t->val; .).
 
 VarIdent<Expression& e>
 = ident                                     (. e = Expression(Atom<Identifier_t>(t->val)); .)
   [ lcurbrack (                              
         ident                               (. SemErr(coco_string_create("var version as ident is not implemented yet")); .)
       | number                              (. Attachments::put<versions::VariableVersion>(e, Atom<Number_t>(t->val).get()); .)
   ) rcurbrack ]
 .
   
 
 FDecl<Function*& f> =       (. std::wstring fname; std::wstring argName; TypeAnnotation typIn; TypeAnnotation typOut; bool flagIsPrefunct = false; Expression binding; .)
 Ident<fname> assign 
 [pre            (. flagIsPrefunct = true; .)]
 function 		(. f = new Function(fname); f->isPrefunction = flagIsPrefunct; CodeScope* entry = f->getEntryScope(); .)
 
 ['(' Ident<argName> tagcolon ExprAnnotations<binding>  (. f->addBinding(Atom<Identifier_t>(argName), move(binding)); .)
 {',' Ident<argName> tagcolon ExprAnnotations<binding>  (. f->addBinding(Atom <Identifier_t>(argName), move(binding));.)
 } ')']
 
 [ tagcolon  
 ( IF(flagIsPrefunct) FnTag<f>
   |  Type<typOut>
 )
 {';' FnTag<f> }]
 BDecl<entry>    (. entry->getBody().bindType(move(typOut));.)
 .
 
 ContextSection<>=                       (. Expression context; Function* f; .)
 "case" "context" tagcolon MetaSimpExpr<context>  
 lcurbrack { FDecl<f>                    (. f->guardContext = context; root->add(f); .)
 } rcurbrack.
 
   /**
    *                          TYPES  
    * 
    */
 TypeTerm<TypePrimitive& typ> =                       (. std::wstring tid; .)
   ("string" (. typ = TypePrimitive::String;.)
   | "num"   (. typ = TypePrimitive::Num;.)
   | "int"   (. typ = TypePrimitive::Int;.)
   | "float" (. typ = TypePrimitive::Float;.)
   | "bool" (. typ = TypePrimitive::Bool; .)
   | "i8"    (. typ = TypePrimitive::I8; .)
   | "i32"   (. typ = TypePrimitive::I32; .)
   | "i64"   (. typ = TypePrimitive::I64; .)
   ).
 
 Type<TypeAnnotation& typ> =  (. TypeAnnotation typ2; TypePrimitive typ3; std::wstring tid, field; .)
 ( 
   TList<typ>   
 | TStruct<typ>
 | TVariant<typ>
 | TypeTerm<typ3> (. typ = typ3; .) 
 | IF (checkIndex()) Ident<tid> lbrack
       Ident<field>      (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
       {',' Ident<field> (.  typ.fields.push_back(Atom<Identifier_t>(field).get());  .)
       } rbrack
       
 | Ident<tid>            (. typ = TypeAnnotation(TypeOperator::CUSTOM, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); .)
     ['(' Type<typ2>     (. typ.__operator = TypeOperator::CALL; typ.__operands.push_back(typ2); .)
     {',' Type<typ2>     (. typ.__operands.push_back(typ2); .)
     } ')']
 ) .
 
 TList<TypeAnnotation& typ> =            (.      TypeAnnotation ty; .)
     '[' Type<ty> ']'                    (. typ = TypeAnnotation(TypeOperator::ARRAY, {ty}); .)
 .
 
 TStruct<TypeAnnotation& typ> = (. TypeAnnotation t; std::wstring key; size_t keyCounter=0; .)
   lcurbrack
     (
         IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon Type<t> 
         | Type<t>       (. key = to_wstring(keyCounter++); .)
         
     )     (. typ = TypeAnnotation(TypeOperator::STRUCT, {t}); typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
     {',' (
         IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon Type<t> 
         | Type<t>       (. key = to_wstring(keyCounter++); .)
         
         ) (. typ.__operands.push_back(t); typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
     } rcurbrack.
   
 TVariant<TypeAnnotation& typ>=  (. TypeAnnotation t, typVoid(TypeOperator::STRUCT, {}); std::vector<TypeAnnotation> operands; std::vector<Atom<Identifier_t>> keys; std::wstring variant; .)
     "variant" lcurbrack
     Ident<variant>              (. t=typVoid; .)        
     [tagcolon Type<t>]          (. keys.push_back(Atom<Identifier_t>(variant)); operands.push_back(t); .)
                           
     {',' Ident<variant>         (. t=typVoid; .)        
     [tagcolon Type<t>]          (. keys.push_back(Atom<Identifier_t>(variant)); operands.push_back(t); .)
     }                           
     rcurbrack                   (. typ = TypeAnnotation(TypeOperator::VARIANT, {}); typ.__operands = operands;  typ.addFields(std::move(keys)); .)
 .    
 
  TDecl =  (. TypeAnnotation t; std::wstring tname, arg; std::vector<Atom<Identifier_t>> args; .)
   Ident<tname> assign "type"
   ['('  Ident<arg>        (. args.push_back(Atom<Identifier_t>(arg));   .)
   {',' Ident<arg>         (. args.push_back(Atom<Identifier_t>(arg));   .)
   } ')']
   Type<t>'.'              (. t.addBindings(move(args)); root->add(move(t), Atom<Identifier_t>(tname)); .)
   .
   
 ContextDecl<CodeScope * scope> =        (. Expression tag; .)
 context tagcolon 
 MetaSimpExpr<tag>                     (. scope->tags.push_back(tag); .)
 {';' MetaSimpExpr<tag>                (. scope->tags.push_back(tag); .)
 }.
 
 VDecl<CodeScope* f> =                       (. std::wstring vname; Expression var, value;.)
     VarIdent<var> assign ExprTyped<value>   (. f->addDeclaration(move(var), move(value)); .)
 .
 
 BDecl<CodeScope* scope> =  lcurbrack      (. Expression body; pushContextScope(scope);  .)
     {(IF(checkAssignment()) VDecl<scope> '.'
     | RuleContextDecl<scope>  
     | ContextDecl<scope>'.'
     | ExprTyped<body>                     (. scope->setBody(body); .)
     )}
     rcurbrack                             (. popContextScope(); .) 
 . 
 
 IfDecl<Expression& e> =     (. Expression cond; ManagedScpPtr blockTrue = root->add(new CodeScope(context.scope)); ManagedScpPtr blockFalse = root->add(new CodeScope(context.scope)); .)
 "if" '(' Expr<cond> ')'                         (. e = Expression(Operator::IF, {cond}); .)
 tagcolon ExprAnnotations<e> 
 BDecl<&*blockTrue> "else" BDecl<&*blockFalse>   (.  e.addBlock(blockTrue); e.addBlock(blockFalse); .)
 .
 
 LoopDecl<Expression& e> = 
   (. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; Expression tagsEl;
     ManagedScpPtr block = root->add(new CodeScope(context.scope)); .)
    "loop"
    ("map" '(' Expr<eIn> implic Ident<varEl>     (. e = Expression(Operator::MAP, {eIn}); .)
-    tagcolon ExprAnnotations<tagsEl> ')' tagcolon ExprAnnotations<e> BDecl<&*block>
-      (.
-         e.addBindings({Atom<Identifier_t>(varEl)});
-         block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl)); 
-         e.addBlock(block); 
-      .)
+    tagcolon ExprAnnotations<tagsEl> ')' tagcolon ExprAnnotations<e> 
+        (.
+            e.addBindings({Atom<Identifier_t>(varEl)});
+            block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl)); 
+        .)
+    BDecl<&*block>
+        (. e.addBlock(block);  .)
 
   |"fold" 
     ("inf" '(' Expr<eAcc> implic Ident<varAcc> ')' 
         (.
                 e = Expression(Operator::FOLD_INF, {eAcc});
                 e.addBindings({Atom<Identifier_t>(varAcc)});
+                block->addBinding(Atom<Identifier_t>(varAcc), Expression());
         .)        
      tagcolon ExprAnnotations<e> BDecl<&*block>
-        (.
-                block->addBinding(Atom<Identifier_t>(varAcc), Expression());
-                e.addBlock(block); 
-        .)
+        (.  e.addBlock(block); .)
   
      | '(' Expr<eIn> implic Ident<varEl> tagcolon ExprAnnotations<tagsEl> ['|' Expr<eFilters> ] ',' Expr<eAcc> implic Ident<varAcc>')'
             (.
                 e = Expression(Operator::FOLD, {eIn, eAcc});
                 e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
             .)
         tagcolon ExprAnnotations<e> 
             (.  
                 block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
                 block->addBinding(Atom<Identifier_t>(varAcc), Expression());
             .)
         BDecl<&*block>
             (.  e.addBlock(block);             .)
     )
   | "context" '(' string                          (. contextClass = t->val; .)
     ')' BDecl<&*block> 
         (. e = Expression(Operator::LOOP_CONTEXT, {Expression(Atom<String_t>(std::move(contextClass)))});
             e.addBlock(block);
          .)
 ).
    
 //              Switches   
 SwitchDecl<Expression& eSwitch, SwitchKind flagSwitchKind> = (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); Expression eCondition; Expression tag;.)
 "switch" 
     (
         SwitchVariantDecl<eSwitch>
         | lparen Expr<eCondition> rparen tagcolon  ExprAnnotations<eSwitch>  (. eSwitch.operands.push_back(eCondition);.)
           CaseDecl<eSwitch, flagSwitchKind> {CaseDecl<eSwitch, flagSwitchKind>}
     ) 
 .
   
 CaseDecl<Expression& outer, SwitchKind flagSwitchKind> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); Expression condition; .)
   "case" 
   ( IF(flagSwitchKind == SWITCH_META)
         lparen MetaSimpExpr<condition> rparen BDecl<&*scope>  (. Expression exprCase(Operator::CASE, {}); exprCase.addTags({condition}); exprCase.addBlock(scope); outer.addArg(move(exprCase));.)
         
     | "default" BDecl<&*scope>                    (. Expression exprCase(Operator::CASE_DEFAULT, {});       
                                                    exprCase.addBlock(scope); 
                                                    outer.operands.insert(++outer.operands.begin(), exprCase); .)
   
     | lparen CaseParams<&*scope> rparen         (. ManagedScpPtr scopeBody = root->add(new CodeScope(&*scope)); Expression exprCase(Operator::CASE, {}); .)
       BDecl<&*scopeBody>                                (. exprCase.addBlock(scope); exprCase.addBlock(scopeBody); outer.addArg(move(exprCase)); .)
  ).
 
 CaseParams<CodeScope* scope> =           (. Expression condition; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .)
  ExprTyped<condition>                  (. guard.addArg(Expression(condition)); .)
    {',' ExprTyped<condition>             (. guard.addArg(Expression(condition)); .)
    }                                     (. scope->setBody(guard); popContextScope(); .)
 .
 
 SwitchVariantDecl<Expression& expr> =                                        
-            (. Expression varTested; expr = Expression(Operator::SWITCH_VARIANT, {}); .)
+            (. Expression varTested; std::wstring varAlias; bool flagAliasFound = false; expr = Expression(Operator::SWITCH_VARIANT, {}); .)
                 
-    "variant" lparen VarIdent<varTested> rparen tagcolon ExprAnnotations<expr>  
-            (. recognizeIdentifier(varTested); expr.addArg(std::move(varTested)); .)
+    "variant" lparen Expr<varTested> [implic Ident<varAlias>
+            (. flagAliasFound = true; .) 
+            
+    ] rparen tagcolon ExprAnnotations<expr>  
+            (. expr.addArg(std::move(varTested)); 
+                if (flagAliasFound) {
+                    expr.addBindings({Atom<Identifier_t>(varAlias)}); 
+                    
+                } else {
+                    if(varTested.__state != Expression::IDENT){
+                        SemErr(coco_string_create("Switch variant expects identifier"));
+                        
+                    }
+                    
+                    expr.addBindings({Atom<Identifier_t>(string(varTested.getValueString()))});
+                }
+            .)
                 
     CaseVariantDecl<expr> {CaseVariantDecl<expr>}
 .    
 
-CaseVariantDecl<Expression& expr> =   (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); std::wstring key; scope->addBinding(Expression(expr.operands.at(0)), Expression()); .)
+CaseVariantDecl<Expression& expr> =   (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); std::wstring key; scope->addBinding(Atom<Identifier_t>(string(expr.bindings.front())), Expression()); .)
     "case" lparen Ident<key> rparen   (. expr.addArg(root->recognizeVariantConstructor(Atom<Identifier_t>(std::move(key))));  .)
     BDecl<&*scope>                    (. expr.addBlock(scope); .)
 .    
     
 IntrinsicDecl<Expression& outer>=        (. std::wstring name; .)
 "intrinsic" Ident< name>                 (. outer = Expression(Operator::CALL_INTRINSIC, {}); outer.setValue(Atom<Identifier_t>(name)); .)
 lparen [CalleeParams<outer>] rparen .
   
                               /*============================ INTERFACES ===============================*/
 Imprt<> =                           
 "import" "raw" lparen string      (. root->__rawImports.push_back(Atom<String_t>(t->val).get()); .) 
 rparen '.'.
 
 InterfaceData<> = "interface" '('
   (   "dfa" ')'  InterfaceDFA
     | "extern-c" ')' InterfaceExternC
     | "cfa" ')' InterfaceCFA
     | "adhoc" ')' InterfaceAdhoc
     
   ).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
 
 InterfaceAdhoc<> = 
     '{' { PrefunctionSchemeDecl }  '}'.
      
 PrefunctionSchemeDecl<> =         (. TypeAnnotation typReturn; std::wstring prefName; Expression exprCases; .)
     pre function Ident<prefName> tagcolon Type<typReturn>
     lcurbrack SwitchDecl<exprCases, SWITCH_META> rcurbrack
                                   (. Expression prefData(Operator::CALL, {Atom<Identifier_t>(prefName), exprCases}); 
                                      prefData.bindType(typReturn); 
                                      root->addInterfaceData(Adhoc, move(prefData));  
                                   .).    
 
 
 InterfaceExternC<>  =   (. ExternData data; .)
   '{' {IncludeExternDecl<data> | LibExternDecl<data> } '}'
       (. root->addExternData(move(data));  .)
 .
 
 LibExternDecl<ExternData& data> =       (. std::wstring pkgname, libname; .)
   Ident<libname> assign "library" tagcolon "pkgconfig" 
   '(' string            (. pkgname = t->val; .)
   ')' '.'               (. data.addLibrary(Atom<Identifier_t>(libname), Atom<String_t>(pkgname)); .)
 . 
 
 IncludeExternDecl<ExternData& data> =   (. Expression inc; .)
   "include" StructLiteral<inc> '.'              (. data.addIncludeDecl(move(inc)); .)
 .
   
 InterfaceDFA<> = '{' { InstructDecl } '}' .
 
 InstructDecl =                        (.Operator op; Expression tag; 
                                   Expression scheme; 
                                   std::vector<Expression>& tags = scheme.operands; 
                                   tags.push_back(Expression()); /* return value */ .)
 "operator" InstructAlias<op> tagcolon '('      (.scheme.setOp(op); .)
 [
   MetaSimpExpr<tag>             (. tags.push_back(tag); .)
   {
       ',' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
   }
 ] ')' [ implic MetaSimpExpr<tag>             (. tags[0] = tag; .) 
       ]                                      (. root->addDFAData(move(scheme)); .)
 '.'.
 
 InstructAlias<Operator& op> = 
 (
    "map"  (. op = Operator::MAP; .)
   | "list_range" (. op = Operator::LIST_RANGE; .)
   | "list"       (. op = Operator::LIST; .)
   | "fold"       (. op = Operator::FOLD; .)
   | "index"      (. op = Operator::INDEX; .) 
 ). 
 
 
 InterfaceCFA<> = '{' { InstructCFADecl } '}' .
 
 InstructCFADecl<> =                          (.Operator op; Expression tag; 
                                                 Expression scheme; 
                                                 std::vector<Expression>& tags = scheme.operands;  .)
 
 "operator" InstructAlias<op> tagcolon     (. scheme.setOp(op); .)
 [
   MetaSimpExpr<tag>             (. tags.push_back(tag); .)
   {
       ',' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
   }
 ] '.'                           (. root->addInterfaceData(CFA, move(scheme)); .).
     
                               /*============================ METAPROGRAMMING ===============================*/
 // TagsDecl<CodeScope* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
 // ':' { MetaSimpExpr<tag> (. /*f.addTag(std::move(tag), mod); */ .)
 // }.
 
 
 FnTag<Function* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
 MetaSimpExpr<tag>
 ['-' TagMod<mod>] (. f->addTag(std::move(tag), mod); .).
 
 TagMod<TagModifier& mod> = 
 (  "assert" (. mod = TagModifier::ASSERT; .)
  | "require" (. mod = TagModifier::REQUIRE; .)
 ).
  
 RuleDecl<> =
 "rule" tagcolon         		(. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .)
 '(' Ident<arg> tagcolon Domain<typ>  	(. args.add(arg, typ); .)
 {',' Ident<arg> tagcolon Domain<typ>  	(. args.add(arg, typ); .)
 } ')'
 ["case" RGuard<guards> {',' RGuard<guards>}]
 '{' RBody<args, guards> '}' .    	
 
 /* - TODO use RGuard for guards-*/
 RuleContextDecl<CodeScope* scope> =     (.Expression eHead, eGuards, eBody; .)
 "rule" "context" tagcolon MetaSimpExpr<eHead>
 "case" lparen MetaSimpExpr<eGuards> rparen
 '{' MetaSimpExpr<eBody> '}'             (.scope->contextRules.push_back(Expression(Operator::CONTEXT_RULE, {eHead, eGuards, eBody})); .).
 
 Domain<DomainAnnotation& dom> = 
 (
   "function"  				(. dom = DomainAnnotation::FUNCTION; .)
   | "variable"    			(. dom = DomainAnnotation::VARIABLE; .)
 ).
 
 RGuard<RuleGuards& guards>=          (. Expression e; .)
 MetaExpr<e>                       (. guards.add(std::move(e)); .).
 
 MetaExpr<Expression& e>=            (.Operator op; Expression e2; .)
 MetaExpr2<e>
 [MetaOp<op> MetaExpr2<e2>           (. e = Expression(op, {e, e2}); .)
 ].
 
 MetaExpr2<Expression& e>=
 (
 '(' MetaExpr<e> ')'
 | MetaSimpExpr<e>
 ).
 
 MetaSimpExpr<Expression& e>=      (. std::wstring i1, infix; Expression e2; .)
 ( '-' MetaSimpExpr<e2>            (. e = Expression(Operator::NEG, {e2}); .)
 | IF(checkParametersList()) Ident<i1>   (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(i1))}); .)
 '(' [ MetaCalleeParams<e> ] ')'
 | IF(checkInfix()) Ident<i1> Ident<infix> MetaSimpExpr<e2>                                       
                                         (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(infix))});
                                            e.addArg(Expression(Atom<Identifier_t>(i1)));
                                            e.addArg(std::move(e2));
                                         .)
 | Ident<i1>                             (. e = Expression(Operator::CALL, {Atom<Identifier_t>(i1)}); .)
 ).
 
 MetaCalleeParams<Expression& e> = (. Expression e2; .)
   MetaSimpExpr<e2>	     	(. e.addArg(Expression(e2)); .)
   {',' MetaSimpExpr<e2>		(. e.addArg(Expression(e2)); .)
   }.
 
 RBody<const RuleArguments& args, const RuleGuards& guards> =
                                   (. Expression e; std::wstring msg; .)
  "warning" MetaExpr<e> ["message" string (. msg = t->val; .)
 ]                                 (. root->add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom<String_t>(msg))); .)
  .
 
 MetaOp< Operator& op> =
  implic                          (. op = Operator::IMPL; .)
 .
 
         /*============================ Expressions ===============================*/
 ExprAnnotations<Expression& e> = (. TypeAnnotation typ; std::list<Expression> tags; Expression tag; e.tags.clear();.)
 Type<typ>                    (. e.bindType(move(typ)); .)
   {';' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
   }                          (. e.addTags(tags); .)
 .
   
 ExprTyped<Expression&e> = Expr<e> [tagcolon ExprAnnotations<e>].
 
 Expr< Expression& e>         (. Operator op; Expression e2; .)
 = ExprArithmAdd<e>		 
   [ RelOp<op>
     ExprArithmAdd<e2>      (. e = Expression(op, {e, e2});  .)
   ].
 
 ExprArithmAdd< Expression& e>=      (. Operator op; Expression e2; .)
   ExprArithmMul< e>
   [ AddOp< op>
     ExprArithmAdd< e2>         (. e = Expression(op, {e, e2});.)
   ].
 
 ExprArithmMul< Expression& e>         (. Operator op; Expression e2; .)
 = ExprPostfix< e>
   [ MulOp< op>
     ExprArithmMul< e2>        (. e = Expression(op, {e, e2}); .)
   ].
 
 ExprPostfix<Expression& e> 
 = Term<e> 
   [lbrack                    (. e = Expression(Operator::INDEX, {e}); .)
     CalleeParams<e> rbrack   
   ].
 
 
 Term< Expression& e>       (. std::wstring name; e = Expression(); .)
 =                        
   (IF (checkParametersList()) Ident< name> 
                                     (. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); root->recognizeVariantConstructor(e); .)
   '(' [CalleeParams<e>] ')'
   | VarIdent<e>                     (. recognizeIdentifier(e); .)
   | ListLiteral<e>                  (. /* tuple */.)    
   | StructLiteral<e>                (. /* struct */.)
   | LoopDecl<e>
   | IfDecl<e>   
   | SwitchDecl<e, SWITCH_NORMAL>
   | AdhocDecl<e>
   | IntrinsicDecl<e>
   | number                          (. e = Expression(Atom<Number_t>(t->val)); .)
   | string                          (. e = Expression(Atom<String_t>(t->val)); .)
   | "true"                          (. e = Expression(Atom<Number_t>(1)); e.bindType(TypePrimitive::Bool); .)
   | "false"                         (. e = Expression(Atom<Number_t>(0)); e.bindType(TypePrimitive::Bool); .)
   | '-' Term<e>                     (. e = Expression(Operator::NEG, {e}); .)
   | '(' ExprTyped<e> ')'  
   ).
   
 StructLiteral<Expression& e> =                     (. std::wstring key; Expression val; std::list<Atom<Identifier_t>> keys; size_t keyCounter=0; .)
   lcurbrack 
         (IF(checkTokenAfterIdent(_assign)) Ident<key> '=' Expr<val>
         | Expr<val>                                (. key = to_wstring(keyCounter++); .)
         )                                          (. keys.push_back(Atom<Identifier_t>(key)); e = Expression(Operator::LIST_NAMED, {val}); .)
   {',' (IF(checkTokenAfterIdent(_assign)) Ident<key> '=' Expr<val>
         | Expr<val>                                (. key = to_wstring(keyCounter++); .)
        )                                           (. e.addArg(Expression(val)); keys.push_back(Atom<Identifier_t>(key)); .)
   } rcurbrack                                      (. e.addBindings(keys.begin(), keys.end()); .)
   .
   
 ListLiteral<Expression& e> =  (. Expression eFrom, eTo; .)
 '['                                                             
 [ Expr<eFrom>                                                   (. e.addArg(Expression(eFrom)); .)
 (".."  Expr<eTo>                                                (. e.addArg(Expression(eTo)); e.setOp(Operator::LIST_RANGE); .)
  |{',' Expr<eFrom>                                              (. e.addArg(Expression(eFrom)); .)
 }                                                               (. e.setOp(Operator::LIST); .) 
 ) ] ']'.
 
 AdhocDecl<Expression& e> = (. Expression command; .)
 "ad" "hoc" MetaSimpExpr<command>       (. adhoc::AdhocExpression exprAdhoc; exprAdhoc.setCommand(command); e = exprAdhoc; .).
 
 CalleeParams<Expression& e> = (. Expression e2; .)
   ExprTyped<e2>		(. e.addArg(Expression(e2)); .)
   {',' ExprTyped<e2> 		(. e.addArg(Expression(e2)); .)
   }.
 
 AddOp< Operator& op>
 =                        (. op = Operator::ADD; .)
   ( '+'
   | '-'                  (. op = Operator::SUB; .)
   ).
 
 MulOp< Operator& op>
 =                        (. op = Operator::MUL; .)
   ( '*'
   | '/'                  (. op = Operator::DIV; .)
   ).
 
 RelOp< Operator& op>
 =                         (. op = Operator::EQU; .)
   ( equal
   | (ne1 | ne2)           (. op = Operator::NE; .)
   
   | lse                   (. op = Operator::LSE; .)
   | lss                   (. op = Operator::LSS; .)
   
   | gte                   (. op = Operator::GTE; .)
   | gtr                   (. op = Operator::GTR; .)
   
   ).
   
 SkipModulesSection = "module" '{' {ANY} '}'.  
   
 END Xreate.