diff --git a/cpp/src/ast.cpp b/cpp/src/ast.cpp
index cee486b..87c974b 100644
--- a/cpp/src/ast.cpp
+++ b/cpp/src/ast.cpp
@@ -1,928 +1,928 @@
 #include "ast.h"
 #include "ExternLayer.h"
 #include "analysis/typeinference.h"
 
 #include <stdexcept>
 #include <iostream>
 
 //TODO BDecl. forbid multiple body declaration (ExprTyped)
 
 namespace std{
     std::size_t
     hash<xreate::ScopedSymbol>::operator()(xreate::ScopedSymbol const& s) const
     {return s.id ^ (s.version << 2);}
 
     bool
     equal_to<xreate::ScopedSymbol>::operator()(const xreate::ScopedSymbol& __x, const xreate::ScopedSymbol& __y) const
     { return __x.id == __y.id && __x.version == __y.version; }
 
     size_t
     hash<xreate::Symbol>::operator()(xreate::Symbol const& s) const{
         return hash<xreate::ScopedSymbol>()(s.identifier) ^ ((long int) s.scope << 1);
     }
 
     bool
     equal_to<xreate::Symbol>::operator()(const xreate::Symbol& __x, const xreate::Symbol& __y) const{
       return __x == __y;
     };
 }
 
 using namespace std;
 
 namespace xreate {
 
 Atom<Identifier_t>::Atom(const std::wstring& value) {
     __value = wstring_to_utf8(value);
 }
 
 Atom<Identifier_t>::Atom(std::string && name) : __value(name)
 {}
 
 const std::string&
 Atom<Identifier_t>::get() const {
     return __value;
 }
 
 Atom<Number_t>::Atom(wchar_t* value) {
     //DEBT reconsider number literal recognition
     __value = wcstol(value, 0, 10);
 }
 
 Atom<Number_t>::Atom(int value)
 : __value(value) {
 }
 
 double
 Atom<Number_t>::get()const {
     return __value;
 }
 
 Atom<String_t>::Atom(const std::wstring& value) {
     assert(value.size() >=2);
     __value = wstring_to_utf8(value.substr(1, value.size() -2));
 }
 
 const std::string&
 Atom<String_t>::get() const {
     return __value;
 }
 
     class ExpressionHints {
     public:
 
         static bool
         isStringValueValid(const Expression& e) {
             switch (e.__state) {
                 case Expression::INVALID:
                     assert(false);
 
                 case Expression::IDENT:
                 case Expression::STRING:
                     return true;
 
                 case Expression::NUMBER:
                 case Expression::BINDING:
-                case Expression::VARIANT:
                     return false;
 
                 case Expression::COMPOUND:
                 {
                     switch (e.op) {
                         case Operator::CALL:
                             return true;
 
                         default: return false;
                     }
                 }
             }
 
             return false;
         }
 
         static bool
         isDoubleValueValid(const Expression& e) {
             switch (e.__state) {
                 case Expression::NUMBER:
-                case Expression::VARIANT:
                     return true;
 
                 case Expression::INVALID:
                     assert(false);
 
                 case Expression::IDENT:
                 case Expression::STRING:
-                case Expression::COMPOUND:
                 case Expression::BINDING:
                     return false;
+
+                case Expression::COMPOUND:{
+                    switch (e.op) {
+                        case Operator::VARIANT:
+                            return true;
+                            default: return false;
+                    }
+                }
             }
 
             return false;
         }
     };
 
     class TypesResolver {
     private:
         const AST* ast;
         std::map<std::string, TypeAnnotation> scope;
         std::map<TypeAnnotation, int> signatures;
 
         ExpandedType expandType(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) {
             return TypesResolver(ast, scope, signatures)(t, args);
         }
 
         std::vector<TypeAnnotation>
         expandOperands(const std::vector<TypeAnnotation>& operands) {
             std::vector<TypeAnnotation> pack;
 
             pack.reserve(operands.size());
             std::transform(operands.begin(), operands.end(), std::inserter(pack, pack.end()),
                     [this](const TypeAnnotation & t) {
                         return expandType(t);
                     });
 
             return pack;
         }
 
     public:
 
         TypesResolver(const AST* root, const std::map<std::string, TypeAnnotation>& scopeOuter = std::map<std::string, TypeAnnotation>(),
                 std::map<TypeAnnotation, int> signaturesOuter = std::map<TypeAnnotation, int>())
         : ast(root), scope(scopeOuter), signatures(signaturesOuter) {
         }
 
         ExpandedType
         operator()(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) {
             //assert(args.size() == t.bindings.size()); // invalid number of arguments
             for (size_t i = 0; i < args.size(); ++i) {
                 scope[t.bindings.at(i)] = args.at(i);
             }
 
             switch (t.__operator) {
                 case TypeOperator::ARRAY:
                 {
                     assert(t.__operands.size() == 1);
 
                     Expanded<TypeAnnotation> elTy = expandType(t.__operands.at(0));
                     return ExpandedType(TypeAnnotation(tag_array, elTy, 0));
                 }
 
                 case TypeOperator::STRUCT:
                 {
                     assert(t.__operands.size());
 
                     std::vector<TypeAnnotation>&& packOperands = expandOperands(t.__operands);
                     auto typNew = TypeAnnotation(TypeOperator::STRUCT, move(packOperands));
                     typNew.fields = t.fields;
 
                     return ExpandedType(move(typNew));
                 };
 
                 case TypeOperator::CALL:
                 {
                     std::string alias = t.__valueCustom;
 
                     //find in local scope:
                     TypeAnnotation ty;
                     if (scope.count(alias)) {
                         ty = scope.at(alias);
 
                     } else if (ast->__indexTypeAliases.count(alias)) {
                         ty = ast->__indexTypeAliases.at(alias);
 
                     } else {
                         assert(false && "Undefined or external type");
                     }
 
                     std::vector<TypeAnnotation>&& operands = expandOperands(t.__operands);
                     TypeAnnotation signature(TypeOperator::CALL, move(operands));
                     signature.__valueCustom = alias;
 
                     if (signatures.count(signature)) {
                         auto link = TypeAnnotation(TypeOperator::LINK,{});
                         link.conjuctionId = signatures.at(signature);
 
                         return ExpandedType(move(link));
                     }
 
                     int cid = signatures.size();
                     signatures[signature] = cid;
                     TypeAnnotation tyResult = expandType(ty, operands);
                     tyResult.conjuctionId = cid;
 
                     return ExpandedType(move(tyResult));
                 };
 
                 case TypeOperator::CUSTOM:
                 {
                     std::string alias = t.__valueCustom;
 
                     /*
                     if (signatures.count(alias)) {
                         return ExpandedType(TypeAnnotation(TypeOperator::LINK, {t}));
                     }
                     signatures[alias].emplace(t);
                      */
 
                     //find in local scope:
                     if (scope.count(alias)) {
                         return expandType(scope.at(alias));
                     }
 
                     // find in general scope:
                     if (ast->__indexTypeAliases.count(alias)) {
                         return expandType(ast->__indexTypeAliases.at(t.__valueCustom));
                     }
 
                     //if type is unknown keep it as is.
                     return ExpandedType(TypeAnnotation(t));
                 };
 
                 case TypeOperator::ACCESS:
                 {
                     std::string alias = t.__valueCustom;
                     ExpandedType tyAlias = ExpandedType(TypeAnnotation());
 
                     //find in local scope:
                     if (scope.count(alias)) {
                         tyAlias = expandType(scope.at(alias));
 
                         //find in global scope:
                     } else if ((ast->__indexTypeAliases.count(alias))) {
                         tyAlias = expandType(ast->__indexTypeAliases.at(alias));
 
                     } else {
                         assert(false && "Undefined or external type");
                     }
 
                     assert(tyAlias->__operator == TypeOperator::STRUCT);
 
                     for (const string& field : t.fields) {
                         auto fieldIt = std::find(tyAlias->fields.begin(), tyAlias->fields.end(), field);
                         assert(fieldIt != tyAlias->fields.end() && "unknown field");
 
                         int fieldId = fieldIt - tyAlias->fields.begin();
                         tyAlias = expandType(tyAlias->__operands.at(fieldId));
                     }
 
                     return tyAlias;
                 }
 
                 case TypeOperator::VARIANT:
                 {
                     return ExpandedType(TypeAnnotation(t));
                 }
 
                 case TypeOperator::NONE:
                 {
                     return ExpandedType(TypeAnnotation(t));
                 }
 
                 default:
                     assert(false);
             }
 
             assert(false);
             return ExpandedType(TypeAnnotation());
         }
     };
 
     TypeAnnotation::TypeAnnotation()
         : __operator(TypeOperator::NONE), __value(TypePrimitive::Invalid)
     {}
 
     TypeAnnotation::TypeAnnotation(TypePrimitive typ)
     : __value(typ) {
     }
 
     TypeAnnotation::TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands)
     : __operator(op), __operands(operands) {
 
     }
 
     TypeAnnotation::TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands)
     : __operator(op), __operands(operands) {
     }
 
     TypeAnnotation::TypeAnnotation(llvm_array_tag, TypeAnnotation typ, int size)
     : TypeAnnotation(TypeOperator::ARRAY,{typ}) {
         __size = size;
     }
 
     bool
     TypeAnnotation::isValid() const{
         return !(__value == TypePrimitive::Invalid && __operator == TypeOperator::NONE);
     }
 
     bool
     TypeAnnotation::operator<(const TypeAnnotation& t) const {
         if (__operator != t.__operator) return __operator < t.__operator;
 
         if (__operator == TypeOperator::NONE)
             return __value < t.__value;
 
         if (__operator == TypeOperator::CALL || __operator == TypeOperator::CUSTOM || __operator == TypeOperator::ACCESS) {
             if (__valueCustom != t.__valueCustom)
                 return __valueCustom < t.__valueCustom;
         }
 
         return __operands < t.__operands;
     }
 
     /*
     TypeAnnotation (struct_tag, std::initializer_list<TypeAnnotation>)
     {}
      */
 
     void
     TypeAnnotation::addBindings(std::vector<Atom<Identifier_t>>&& params) {
         bindings.reserve(bindings.size() + params.size());
 
         std::transform(params.begin(), params.end(), std::inserter(bindings, bindings.end()),
                 [](const Atom<Identifier_t>& ident) {
                     return ident.get(); });
     }
 
     void
     TypeAnnotation::addFields(std::vector<Atom<Identifier_t>>&& listFields) {
         fields.reserve(fields.size() + listFields.size());
 
         std::transform(listFields.begin(), listFields.end(), std::inserter(fields, fields.end()),
                 [](const Atom<Identifier_t>& ident) {
                     return ident.get(); });
     }
 
     unsigned int Expression::nextVacantId = 0;
 
     Expression::Expression(const Atom<Number_t>& number)
     : Expression() {
         __state=NUMBER; op=Operator::NONE; __valueD=number.get();
     }
 
     Expression::Expression(const Atom<String_t>& a)
     : Expression(){
         __state=STRING; op=Operator::NONE; __valueS=a.get();
     }
 
     Expression::Expression(const Atom<Identifier_t> &ident)
     : Expression() {
         __state=IDENT; op=Operator::NONE; __valueS=ident.get();
     }
 
     Expression::Expression(const Operator &oprt, std::initializer_list<Expression> params)
     : Expression() {
         __state=COMPOUND; op=oprt;
 
         if (op == Operator::CALL) {
             assert(params.size() > 0);
             Expression arg = *params.begin();
 
             assert(arg.__state == Expression::IDENT);
             __valueS = std::move(arg.__valueS);
 
             operands.insert(operands.end(), params.begin() + 1, params.end());
             return;
         }
 
         operands.insert(operands.end(), params.begin(), params.end());
     }
 
     void
     Expression::setOp(Operator oprt) {
         op = oprt;
 
         switch (op) {
             case Operator::NONE:
                 __state = INVALID;
                 break;
 
             default:
                 __state = COMPOUND;
                 break;
         }
     }
 
     void
     Expression::addArg(Expression &&arg) {
         operands.push_back(arg);
     }
 
     void
     Expression::addTags(const std::list<Expression> tags) const{
         std::transform(tags.begin(), tags.end(), std::inserter(this->tags, this->tags.end()),
             [](const Expression& tag){
                 return make_pair(tag.getValueString(), tag);
         });
     }
 
     void
     Expression::addBindings(std::initializer_list<Atom<Identifier_t>> params) {
         addBindings(params.begin(), params.end());
     }
 
     void
     Expression::bindType(TypeAnnotation t) {
         type = move(t);
     }
 
     void
     Expression::addBlock(ManagedScpPtr scope) {
         blocks.push_back(scope.operator->());
     }
 
     const std::vector<Expression>&
     Expression::getOperands() const {
         return operands;
     }
 
     double
     Expression::getValueDouble() const {
         return __valueD;
     }
 
     const std::string&
     Expression::getValueString() const {
         return __valueS;
     }
 
     void
     Expression::setValue(const Atom<Identifier_t>&& v) {
         __valueS = v.get();
     }
 
     void Expression::setValueDouble(double value) {
         __valueD = value;
     }
 
     bool
     Expression::isValid() const {
         return (__state != INVALID);
     }
 
     bool
     Expression::isDefined() const {
         return (__state != BINDING);
     }
 
     Expression::Expression()
     : __state(INVALID), op(Operator::NONE), id(nextVacantId++)
     {    }
 
 namespace details { namespace incomplete {
 AST::AST() {
     Attachments::init<versions::VariableVersion>();
     Attachments::init<Symbol>();
 }
 
 void
 AST::addInterfaceData(const ASTInterface& interface, Expression&& data) {
     __interfacesData.emplace(interface, move(data));
 }
 
 void
 AST::addDFAData(Expression &&data) {
     __dfadata.push_back(data);
 }
 
 void
 AST::addExternData(ExternData &&data) {
     __externdata.insert(__externdata.end(), data.entries.begin(), data.entries.end());
 }
 
 void
 AST::add(Function* f) {
     __functions.push_back(f);
     __indexFunctions.emplace(f->getName(), __functions.size() - 1);
 }
 
 void
 AST::add(MetaRuleAbstract *r) {
     __rules.push_back(r);
 }
 
 void
 AST::add(TypeAnnotation t, Atom<Identifier_t> alias) {
     if (t.__operator == TypeOperator::VARIANT) {
         for (int i = 0, size = t.fields.size(); i < size; ++i) {
             __dictVariants.emplace(t.fields[i], make_pair(t, i));
         }
     }
 
     __indexTypeAliases.emplace(alias.get(), move(t));
 }
 
 ManagedScpPtr
 AST::add(CodeScope* scope) {
     this->__scopes.push_back(scope);
     return ManagedScpPtr(this->__scopes.size() - 1, &this->__scopes);
 }
 
 std::string
 AST::getModuleName() {
     const std::string name = "moduleTest";
 
     return name;
 }
 
 ManagedPtr<Function>
 AST::findFunction(const std::string& name) {
     int count = __indexFunctions.count(name);
     if (!count) {
         return ManagedFnPtr::Invalid();
     }
 
     assert(count == 1);
 
     auto range = __indexFunctions.equal_range(name);
     return ManagedPtr<Function>(range.first->second, &this->__functions);
 }
 
 std::list<ManagedFnPtr>
 AST::getAllFunctions() const {
     const size_t size = __functions.size();
 
     std::list<ManagedFnPtr> result;
     for (size_t i = 0; i < size; ++i) {
         result.push_back(ManagedFnPtr(i, &this->__functions));
     }
 
     return result;
 }
 
 //TASK select default  specializations
 
 std::list<ManagedFnPtr>
 AST::getFunctionVariants(const std::string& name) const {
     auto functions = __indexFunctions.equal_range(name);
 
     std::list<ManagedFnPtr> result;
     std::transform(functions.first, functions.second, inserter(result, result.end()),
             [this](auto f) {
                 return ManagedFnPtr(f.second, &this->__functions);
             });
 
     return result;
 }
 
 template<>
 ManagedPtr<Function>
 AST::begin<Function>() {
     return ManagedPtr<Function>(0, &this->__functions);
 }
 
 template<>
 ManagedPtr<CodeScope>
 AST::begin<CodeScope>() {
     return ManagedPtr<CodeScope>(0, &this->__scopes);
 }
 
 template<>
 ManagedPtr<MetaRuleAbstract>
 AST::begin<MetaRuleAbstract>() {
     return ManagedPtr<MetaRuleAbstract>(0, &this->__rules);
 }
 
-bool
-AST::recognizeVariantIdentifier(Expression& identifier) {
-    assert(identifier.__state == Expression::IDENT);
+void
+AST::recognizeVariantConstructor(Expression& function) {
+    assert(function.op == Operator::CALL);
 
-    std::string variant = identifier.getValueString();
+    std::string variant = function.getValueString();
     if (!__dictVariants.count(variant)) {
-        return false;
+        return;
     }
 
     auto record = __dictVariants.at(variant);
     const TypeAnnotation& typ = record.first;
 
-    identifier.__state = Expression::VARIANT;
-    identifier.setValueDouble(record.second);
-    identifier.type = typ;
-
-    return true;
+    function.op = Operator::VARIANT;
+    function.setValueDouble(record.second);
+    function.type = typ;
 }
 
 void
 AST::postponeIdentifier(CodeScope* scope, const Expression& id) {
     bucketUnrecognizedIdentifiers.emplace(scope, id);
 }
 
 void
 AST::recognizePostponedIdentifiers() {
     for(const auto& identifier: bucketUnrecognizedIdentifiers){
         if (!identifier.first->recognizeIdentifier(identifier.second)){
             //exception: Ident not found
             std::cout << "Unknown symbol: "<< identifier.second.getValueString() << std::endl;
             assert(false && "Symbol not found");
         }
     }
 }
 
 xreate::AST*
 AST::finalize() {
     //all finalization steps:
     recognizePostponedIdentifiers();
 
     return reinterpret_cast<xreate::AST*>(this);
 }
 }} //namespace details::incomplete
 
 Expanded<TypeAnnotation>
 AST::findType(const std::string& name) {
     // find in general scope:
     if (__indexTypeAliases.count(name))
         return expandType(__indexTypeAliases.at(name));
 
     //if type is unknown keep it as is.
     TypeAnnotation t(TypeOperator::CUSTOM,{});
     t.__valueCustom = name;
     return ExpandedType(move(t));
 }
 
 Expanded<TypeAnnotation>
 AST::expandType(const TypeAnnotation &t) const {
     return TypesResolver(this)(t);
 }
 
 ExpandedType
 AST::getType(const Expression& expression){
     return typeinference::getType(expression, *this);
 }
 
     Function::Function(const Atom<Identifier_t>& name)
     : __entry(new CodeScope(0)) {
         __name = name.get();
     }
 
     void
     Function::addTag(Expression&& tag, const TagModifier mod) {
         string name = tag.getValueString();
         __tags.emplace(move(name), move(tag));
     }
 
     const std::map<std::string, Expression>&
     Function::getTags() const {
         return __tags;
     }
 
     CodeScope*
     Function::getEntryScope() const {
         return __entry;
     }
 
     void
     Function::addBinding(Atom <Identifier_t>&& name, Expression&& argument) {
         __entry->addBinding(move(name), move(argument));
     }
 
     const std::string&
     Function::getName() const {
         return __name;
     }
 
     ScopedSymbol
     CodeScope::registerIdentifier(const Expression& identifier) {
         versions::VariableVersion version = Attachments::get<versions::VariableVersion>(identifier, versions::VERSION_NONE);
 
         auto result = __identifiers.emplace(identifier.getValueString(), __vCounter);
         if (result.second){
             ++__vCounter;
             return {__vCounter-1, version};
         }
 
         return {result.first->second, version};
     }
 
     bool
     CodeScope::recognizeIdentifier(const Expression& identifier) const{
         versions::VariableVersion version = Attachments::get<versions::VariableVersion>(identifier, versions::VERSION_NONE);
         const std::string& name = identifier.getValueString();
 
         //search identifier in the current block
         if (__identifiers.count(name)){
             VNameId id = __identifiers.at(name);
 
             Symbol s;
             s.identifier = ScopedSymbol{id, version};
             s.scope = const_cast<CodeScope*>(this);
             Attachments::put<Symbol>(identifier, s);
 
             return true;
         }
 
         //search in the parent scope
         if (__parent)
         {
             return __parent->recognizeIdentifier(identifier);
         }
 
         return false;
     }
 
     ScopedSymbol
     CodeScope::getSymbol(const std::string& alias){
         assert(__identifiers.count(alias));
         VNameId id = __identifiers.at(alias);
 
         return {id, versions::VERSION_NONE};
     }
 
     void
     CodeScope::addBinding(Expression&& var, Expression&& argument) {
         argument.__state = Expression::BINDING;
 
         __bindings.push_back(var.getValueString());
         ScopedSymbol binding = registerIdentifier(var);
         __declarations[binding] = move(argument);
     }
 
     void
     CodeScope::addDeclaration(Expression&& var, Expression&& body) {
         ScopedSymbol s = registerIdentifier(var);
         __declarations[s] = move(body);
     }
 
     CodeScope::CodeScope(CodeScope* parent)
     : __parent(parent) {
     }
 
     CodeScope::~CodeScope() {
     }
 
     void
     CodeScope::setBody(const Expression &body) {
         __declarations[ScopedSymbol::RetSymbol] = body;
     }
 
     Expression&
     CodeScope::getBody() {
         return __declarations[ScopedSymbol::RetSymbol];
     }
 
     const Expression&
     CodeScope::getDeclaration(const Symbol& symbol) {
         CodeScope* self = symbol.scope;
         return self->getDeclaration(symbol.identifier);
     }
 
     const Expression&
     CodeScope::getDeclaration(const ScopedSymbol& symbol){
         assert(__declarations.count(symbol) && "Symbol's declaration not found");
 
         return __declarations.at(symbol);
     }
 
     void
     RuleArguments::add(const Atom<Identifier_t> &arg, DomainAnnotation typ) {
         emplace_back(arg.get(), typ);
     }
 
     void
     RuleGuards::add(Expression&& e) {
         push_back(e);
     }
 
     MetaRuleAbstract::
     MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards)
     : __args(std::move(args)), __guards(std::move(guards)) {
     }
 
     MetaRuleAbstract::~MetaRuleAbstract() {
     }
 
     RuleWarning::
     RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message)
     : MetaRuleAbstract(std::move(args), std::move(guards)), __message(message.get()), __condition(condition) {
     }
 
     RuleWarning::~RuleWarning() {
     }
 
     void
     RuleWarning::compile(ClaspLayer& layer) {
         //TODO restore addRuleWarning
         //layer.addRuleWarning(*this);
     }
 
     bool operator<(const ScopedSymbol& s1, const ScopedSymbol& s2) {
         return (s1.id < s2.id) || (s1.id==s2.id && s1.version < s2.version);
     }
 
     bool operator==(const ScopedSymbol& s1, const ScopedSymbol& s2) {
         return (s1.id == s2.id) && (s1.version == s2.version);
     }
 
     bool operator<(const Symbol& s1, const Symbol& s2) {
         return (s1.scope < s2.scope) || (s1.scope == s2.scope && s1.identifier < s2.identifier);
     }
 
     bool operator==(const Symbol& s1, const Symbol& s2) {
         return (s1.scope == s2.scope) && (s1.identifier == s2.identifier);
     }
 
     bool operator<(const Expression&a, const Expression&b) {
         if (a.__state != b.__state) return a.__state < b.__state;
         assert(a.__state != Expression::INVALID);
         switch (a.__state) {
             case Expression::IDENT:
             case Expression::STRING:
-            case Expression::VARIANT:
-                return a.getValueString() < b.getValueString();
-
             case Expression::NUMBER:
                 return a.getValueDouble() < b.getValueDouble();
 
             case Expression::COMPOUND:
             {
                 assert(a.blocks.size() == 0);
                 assert(b.blocks.size() == 0);
 
                 if (a.op != b.op){
                     return a.op < b.op;
                 }
 
                 bool flagAValid = ExpressionHints::isStringValueValid(a);
                 bool flagBValid = ExpressionHints::isStringValueValid(b);
 
                 if (flagAValid != flagBValid) {
                     return flagAValid < flagBValid;
                 }
 
                 if (flagAValid){
                     if (a.getValueString() != b.getValueString()) {
                         return a.getValueString() < b.getValueString();
                     }
                 }
 
                 flagAValid = ExpressionHints::isDoubleValueValid(a);
                 flagBValid = ExpressionHints::isDoubleValueValid(b);
 
                 if (flagAValid != flagBValid) {
                     return flagAValid < flagBValid;
                 }
 
                 if (flagAValid){
                     if (a.getValueDouble() != b.getValueDouble()) {
                         return a.getValueDouble() < b.getValueDouble();
                     }
                 }
 
                 if (a.operands.size() != b.operands.size()) {
                     return (a.operands.size() < b.operands.size());
                 }
 
                 for (size_t i = 0; i < a.operands.size(); ++i) {
                     bool result = a.operands[i] < b.operands[i];
                     if (result) return true;
                 }
 
                 return false;
             }
 
             case Expression::BINDING:
             case Expression::INVALID:
                 assert(false);
         }
 
         return false;
     }
 
     bool
     Expression::operator==(const Expression& other) const {
         if (this->__state != other.__state) return false;
 
         if (ExpressionHints::isStringValueValid(*this)) {
             if (this->__valueS != other.__valueS) return false;
         }
 
         if (ExpressionHints::isDoubleValueValid(*this)) {
             if (this->__valueD != other.__valueD) return false;
         }
 
         if (this->__state != Expression::COMPOUND) {
             return true;
         }
 
         if (this->op != other.op) {
             return false;
         }
 
         if (this->operands.size() != other.operands.size()) {
             return false;
         }
 
         for (size_t i = 0; i<this->operands.size(); ++i) {
             if (!(this->operands[i] == other.operands[i])) return false;
         }
 
         assert(!this->blocks.size());
         assert(!other.blocks.size());
 
         return true;
     }
 
 const ScopedSymbol
 ScopedSymbol::RetSymbol = ScopedSymbol{0, versions::VERSION_NONE};
 }
 
 
 
 
diff --git a/cpp/src/ast.h b/cpp/src/ast.h
index f7cbb79..5a71e8e 100644
--- a/cpp/src/ast.h
+++ b/cpp/src/ast.h
@@ -1,577 +1,577 @@
 #ifndef AST_H
 #define AST_H
 
 #include "attachments.h"
 
 #include <vector>
 #include <stdlib.h>
 #include <string>
 #include <list>
 #include <unordered_map>
 #include <unordered_set>
 #include <climits>
 #include "utils.h"
 #include <algorithm>
 
 namespace llvm {
     class Value;
 }
 
 namespace xreate{
     struct ScopedSymbol;
     struct Symbol;
 }
 
 namespace std
 {
     template<>
     struct hash<xreate::ScopedSymbol>{
         std::size_t operator()(xreate::ScopedSymbol const& s) const;
     };
 
     template<>
     struct equal_to<xreate::ScopedSymbol>{
       bool operator()(const xreate::ScopedSymbol& __x, const xreate::ScopedSymbol& __y) const;
     };
     
     template<>
     struct hash<xreate::Symbol>{
         size_t operator()(xreate::Symbol const& s) const;
     };
 
     template<>
     struct equal_to<xreate::Symbol>{
       bool operator()(const xreate::Symbol& __x, const xreate::Symbol& __y) const;
     };
 }
 
 namespace xreate {
 
 struct String_t {
 };
 
 struct Identifier_t {
 };
 
 struct Number_t {
 };
 
 struct Type_t {
 };
 
 template<typename A>
 class Atom {
 };
 
 //DEBT hold for all atoms/identifiers Parser::Token data, like line:col position
 template<> class 
 Atom<Identifier_t> {
 public:
     Atom(const std::wstring& value);
     Atom(std::string && name);
     const std::string& get() const;
     
 private:
     std::string __value;
 };
 
 template<> 
 class Atom<Number_t> {
 public:
     Atom(wchar_t* value);
     Atom(int value);
     double get()const;
     
 private:
     double __value;
 };
 
 template<> 
 class Atom<String_t> {
 public:
     Atom(const std::wstring& value);
     const std::string& get() const;
 
 private:
     std::string __value;
 };
 
 enum class TypePrimitive {
     Invalid, Bool, I8, I32, I64, Num, Int, Float, String
 };
 
 enum class TypeOperator {
         NONE, CALL, CUSTOM, VARIANT, ARRAY, STRUCT, ACCESS, LINK
 };
 
 struct llvm_array_tag {
 };
 
 struct struct_tag {
 };
 const llvm_array_tag tag_array = llvm_array_tag();
 const struct_tag tag_struct = struct_tag();
 
 class TypeAnnotation {
 public:
     TypeAnnotation();
     TypeAnnotation(const Atom<Type_t>& typ);
     TypeAnnotation(TypePrimitive typ);
     TypeAnnotation(llvm_array_tag, TypeAnnotation typ, int size);
 
     TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands);
     TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands);
     void addBindings(std::vector<Atom<Identifier_t>>&& params);
     void addFields(std::vector<Atom<Identifier_t>>&& listFields);
     bool operator<(const TypeAnnotation& t) const;
     //   TypeAnnotation (struct_tag, std::initializer_list<TypePrimitive>);
 
     bool isValid() const;
 
     TypeOperator __operator = TypeOperator::NONE;
 
     std::vector<TypeAnnotation> __operands;
     TypePrimitive __value;
     std::string __valueCustom;
     int conjuctionId = -1; //conjunction point id (relevant for recursive types)
 
     uint64_t __size = 0;
     std::vector<std::string> fields;
     std::vector<std::string> bindings;
 private:
 };
 
 enum class Operator {
     ADD, SUB, MUL, DIV,
     EQU, NE, NEG, LSS, 
     LSE, GTR, GTE, LIST, 
     LIST_RANGE, LIST_NAMED, 
     CALL, CALL_INTRINSIC, NONE, 
     IMPL/* implication */, MAP, 
     FOLD, FOLD_INF, LOOP_CONTEXT, 
     INDEX, IF, SWITCH, SWITCH_ADHOC, 
     CASE, CASE_DEFAULT, LOGIC_AND, 
-    ADHOC, CONTEXT_RULE
+    ADHOC, CONTEXT_RULE, VARIANT
 };
 
 class Function;
 class AST;
 class CodeScope;
 class MetaRuleAbstract;
 
 template<class Target>
 struct ManagedPtr {
 
     static ManagedPtr<Target> Invalid() {
         return ManagedPtr<Target>();
     }
 
     ManagedPtr() : __storage(0) {
     }
 
     ManagedPtr(unsigned int id, const std::vector<Target*>* storage)
     : __id(id), __storage(storage) {
     }
 
     Target&
     operator*() const {
         assert(isValid() && "Invalid Ptr");
         return *__storage->at(__id);
     }
 
     void operator=(const ManagedPtr<Target>& other) {
         __id = other.__id;
         __storage = other.__storage;
     }
 
     bool
     operator==(const ManagedPtr<Target>& other) {
         return isValid() && (__id == other.__id);
     }
 
     Target*
     operator->() const noexcept {
         assert(isValid() && "Invalid Ptr");
         return __storage->at(__id);
     }
 
     inline bool isValid() const {
         return (__storage) && (0 <= __id) && (__id < __storage->size());
     }
 
     inline operator bool() const {
         return isValid();
     }
 
     ManagedPtr<Target>& operator++() {
         ++__id;
         return *this;
     }
 
     inline unsigned int id() const {
         return __id;
     }
 
 private:
     unsigned int __id = 0;
     const std::vector<Target*> * __storage = 0;
 };
 
 typedef ManagedPtr<Function> ManagedFnPtr;
 typedef ManagedPtr<CodeScope> ManagedScpPtr;
 typedef ManagedPtr<MetaRuleAbstract> ManagedRulePtr;
 const ManagedScpPtr NO_SCOPE = ManagedScpPtr(UINT_MAX, 0);
 
 //To update ExpressionHints in case of any changes 
 struct Expression {
     friend class CodeScope;
     friend class ClaspLayer;
     friend class CFAPass;
     friend class ExpressionHints;
 
     Expression(const Operator &oprt, std::initializer_list<Expression> params);
     Expression(const Atom<Identifier_t>& ident);
     Expression(const Atom<Number_t>& number);
     Expression(const Atom<String_t>& a);
 
     Expression();
 
     void setOp(Operator oprt);
     void addArg(Expression&& arg);
     void addBindings(std::initializer_list<Atom<Identifier_t>> params);
     void bindType(TypeAnnotation t);
 
     template<class InputIt>
     void addBindings(InputIt paramsBegin, InputIt paramsEnd);
     void addTags(const std::list<Expression> tags) const;
     void addBlock(ManagedScpPtr scope);
 
     const std::vector<Expression>& getOperands() const;
     double getValueDouble() const;
     void setValueDouble(double value);
     const std::string& getValueString() const;
     void setValue(const Atom<Identifier_t>&& v);
     bool isValid() const;
     bool isDefined() const;
 
 
     bool operator==(const Expression& other) const;
 
     enum {
-        INVALID, COMPOUND, IDENT, NUMBER, STRING, VARIANT, BINDING
+        INVALID, COMPOUND, IDENT, NUMBER, STRING, BINDING
     } __state = INVALID;
 
     Operator op;
     unsigned int id;
     std::vector<std::string> bindings;
     std::map<std::string, size_t> __indexBindings;
     std::vector<Expression> operands;
     TypeAnnotation type;
 
     mutable std::map<std::string, Expression> tags;
     std::list<CodeScope*> blocks;
 
 private:
     std::string __valueS;
     double __valueD;
 
     static unsigned int nextVacantId;
 };
 
 bool operator< (const Expression&, const Expression&);
 
 template<class InputIt>
 void Expression::addBindings(InputIt paramsBegin, InputIt paramsEnd) {
     size_t index = bindings.size();
 
     std::transform(paramsBegin, paramsEnd, std::inserter(bindings, bindings.end()),
             [&index, this] (const Atom<Identifier_t> atom) {
                 std::string key = atom.get();
                 this->__indexBindings[key] = index++;
                 return key;
             });
 }
 
 typedef std::list<Expression> ExpressionList;
 
 enum class TagModifier {
     NONE, ASSERT, REQUIRE
 };
 
 enum class DomainAnnotation {
     FUNCTION, VARIABLE
 };
 
 class RuleArguments : public std::vector<std::pair<std::string, DomainAnnotation>>
 {
     public:
     void add(const Atom<Identifier_t>& name, DomainAnnotation typ);
 };
 
 class RuleGuards : public std::vector<Expression> {
 public:
     void add(Expression&& e);
 };
 
 
 class ClaspLayer;
 class LLVMLayer;
 
 class MetaRuleAbstract {
 public:
     MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards);
     virtual ~MetaRuleAbstract();
     virtual void compile(ClaspLayer& layer) = 0;
 protected:
     RuleArguments __args;
     RuleGuards __guards;
 };
 
 class RuleWarning : public MetaRuleAbstract {
     friend class ClaspLayer;
 public:
     RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message);
     virtual void compile(ClaspLayer& layer);
     ~RuleWarning();
 
 private:
     std::string __message;
     Expression __condition;
 };
 
 typedef unsigned int VNameId;
 
 namespace versions {
     typedef int VariableVersion;
     const VariableVersion VERSION_NONE = -2;
     const VariableVersion VERSION_INIT = 0;
 }
 
 template<>
 struct AttachmentsDict<versions::VariableVersion>
 {
     typedef versions::VariableVersion Data;
     static const unsigned int key = 6;
 };
 
 struct ScopedSymbol{
     VNameId id;
     versions::VariableVersion version;
 
     static const ScopedSymbol RetSymbol;
 };
 
 struct Symbol {
     ScopedSymbol identifier;
     CodeScope * scope;
 };
 
 template<>
 struct AttachmentsDict<Symbol>
 {
     typedef Symbol Data;
     static const unsigned int key = 7;
 };
     
 typedef std::pair<Expression, TagModifier> Tag;
 
 bool operator<(const ScopedSymbol& s1, const ScopedSymbol& s2);
 bool operator==(const ScopedSymbol& s1, const ScopedSymbol& s2);
 bool operator<(const Symbol& s1, const Symbol& s2);
 bool operator==(const Symbol& s1, const Symbol& s2);
 
 class CodeScope {
     friend class Function;
     friend class PassManager;
 
 public:
     CodeScope(CodeScope* parent = 0);
     void setBody(const Expression& body);
     Expression& getBody();
     void addDeclaration(Expression&& var, Expression&& body);
     void addBinding(Expression&& var, Expression&& argument);
     static const Expression& getDeclaration(const Symbol& symbol);
     const Expression& getDeclaration(const ScopedSymbol& symbol);
 
     ~CodeScope();
 
     std::vector<std::string> __bindings;
     std::map<std::string, VNameId> __identifiers;
     CodeScope* __parent;
 
     //TODO move __definitions to SymbolsAttachments data
     //NOTE: definition of return type has zero(0) variable index
     std::unordered_map<ScopedSymbol, Expression> __declarations;
     std::vector<Expression> tags;
     std::vector<Expression> contextRules;
 private:
     VNameId __vCounter = 1;
     ScopedSymbol registerIdentifier(const Expression& identifier);
 
 public:
     bool recognizeIdentifier(const Expression& identifier) const;
     ScopedSymbol getSymbol(const std::string& alias);
 };
 
 class Function {
     friend class Expression;
     friend class CodeScope;
     friend class AST;
 
 public:
     Function(const Atom<Identifier_t>& name);
 
     void addBinding(Atom <Identifier_t>&& name, Expression&& argument);
     void addTag(Expression&& tag, const TagModifier mod);
 
     const std::string& getName() const;
     const std::map<std::string, Expression>& getTags() const;
     CodeScope* getEntryScope() const;
     CodeScope* __entry;
     std::string __name;
     bool isPrefunction = false; //SECTIONTAG adhoc Function::isPrefunction flag
 
     Expression guardContext;
 private:
 
     std::map<std::string, Expression> __tags;
 };
 
 
 class ExternData;
 
 struct ExternEntry {
     std::string package;
     std::vector<std::string> headers;
 };
 
 typedef Expanded<TypeAnnotation> ExpandedType;
 
 enum ASTInterface {
     CFA, DFA, Extern, Adhoc
 };
 
 struct FunctionSpecialization {
     std::string guard;
     size_t id;
 };
 
 struct FunctionSpecializationQuery {
     std::unordered_set<std::string> context;
 };
 
 template<>
 struct AttachmentsId<Expression>{
     static unsigned int getId(const Expression& expression){
         return expression.id;
     }
 };
 
 template<>
 struct AttachmentsId<Symbol>{
     static unsigned int getId(const Symbol& s){
         return s.scope->__declarations.at(s.identifier).id;
     }
 };
 
 template<>
 struct AttachmentsId<ManagedFnPtr>{
     static unsigned int getId(const ManagedFnPtr& f){
         const Symbol symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};
         
         return AttachmentsId<Symbol>::getId(symbolFunction);
     }
 };
 
 namespace details { namespace incomplete {
 class AST {
 public:
     AST();
 
     //TASK extern and DFA interfaces move into addInterfaceData
     /**
      *  DFA Interface
      */
     void addDFAData(Expression&& data);
 
     /**
      * Extern Interface
      */
     void addExternData(ExternData&& data);
 
     void addInterfaceData(const ASTInterface& interface, Expression&& data);
     void add(Function* f);
 
     void add(MetaRuleAbstract* r);
     ManagedScpPtr add(CodeScope* scope);
 
     std::string getModuleName();
     ManagedPtr<Function> findFunction(const std::string& name);
 
     typedef std::multimap<std::string, unsigned int> FUNCTIONS_REGISTRY;
     std::list<ManagedFnPtr> getAllFunctions() const;
     std::list<ManagedFnPtr> getFunctionVariants(const std::string& name) const;
 
 
     template<class Target>
     ManagedPtr<Target> begin();
 
     std::vector<ExternEntry> __externdata;
     std::list<Expression> __dfadata; //TODO move to more appropriate place
     std::list<std::string> __rawImports; //TODO move to more appropriate place
     std::multimap<ASTInterface, Expression> __interfacesData; //TODO CFA data here.
 
 private:
     std::vector<MetaRuleAbstract*> __rules;
     std::vector<Function*> __functions;
     std::vector<CodeScope*> __scopes;
 
     FUNCTIONS_REGISTRY __indexFunctions;
 
 
     // ***** TYPES SECTION *****
 public:
     std::map<std::string, TypeAnnotation> __indexTypeAliases;
     
     ExpandedType getType(const Expression& expression);
     void add(TypeAnnotation t, Atom<Identifier_t> alias);
     
     // ***** SYMBOL RECOGNITION *****
     //TODO revisit enums/variants, move to codescope
-    bool recognizeVariantIdentifier(Expression& identifier);
+    void recognizeVariantConstructor(Expression& function);
 
 private:
     std::map<std::string, std::pair<TypeAnnotation, int>> __dictVariants;
             
 public:
     std::set<std::pair<CodeScope*, Expression>> bucketUnrecognizedIdentifiers;
 
 public:
     void postponeIdentifier(CodeScope* scope, const Expression& id);
     void recognizePostponedIdentifiers();
     xreate::AST* finalize();
 };
 
 template<>
 ManagedPtr<Function>
 AST::begin<Function>();
 
 template<>
 ManagedPtr<CodeScope>
 AST::begin<CodeScope>();
 
 template<>
 ManagedPtr<MetaRuleAbstract>
 AST::begin<MetaRuleAbstract>();
 
 } } // namespace details::incomplete
 
 class AST: public details::incomplete::AST{
 public: 
     AST(): details::incomplete::AST() {}  
     ExpandedType expandType(const TypeAnnotation &t) const;
     ExpandedType findType(const std::string& name);
     ExpandedType getType(const Expression& expression);
 };
 }
 #endif // AST_H
diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
index 513a3a2..b47498c 100644
--- a/cpp/src/compilation/targetinterpretation.cpp
+++ b/cpp/src/compilation/targetinterpretation.cpp
@@ -1,442 +1,441 @@
 /*
  * File:   targetinterpretation.cpp
  * Author: pgess
  *
  * Created on June 29, 2016, 6:45 PM
  */
 
 #include "compilation/targetinterpretation.h"
 #include "pass/interpretationpass.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;
 }
 
 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 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::VARIANT:
         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::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/adhocpass.cpp b/cpp/src/pass/adhocpass.cpp
index 411efa3..ee71b28 100644
--- a/cpp/src/pass/adhocpass.cpp
+++ b/cpp/src/pass/adhocpass.cpp
@@ -1,95 +1,96 @@
 /*
  * adhoc.cpp
  *
  *  Created on: Nov 28, 2015
  *      Author: pgess
  */
 
 #include "pass/adhocpass.h"
 #include "query/context.h"
 
+//TODO use ADT/templated types rather than adhocs. remove adhocs.
 namespace xreate { namespace adhoc {
 
 AdhocExpression::AdhocExpression(): Expression(Operator::ADHOC, {})
 {}
 
 AdhocExpression::AdhocExpression(const Expression& base): Expression(base)
 {}
 
 void
 AdhocExpression::setCommand(const Expression& comm){
     this->addTags({Expression(Operator::CALL, {Atom<Identifier_t>("adhoc"), comm})});
 }
 
 Expression
 AdhocExpression::getCommand() const{
     assert(this->tags.count("adhoc"));
     return this->tags.at("adhoc").getOperands().at(0);
 }
 
 AdhocScheme*
 AdhocPass::findAssotiatedScheme(CodeScope* entry){
     const ScopePacked scopeId = man->clasp->pack(entry);
     const context::Domain& domain = queryContext->getContext(scopeId);
     AdhocScheme* scheme = nullptr;
 
     for (const Expression& context: domain){
         if (!(context.__state == Expression::COMPOUND && context.op == Operator::CALL)) continue;
 
         if (__schemes.count(context.getValueString())){
                 assert(!scheme && "Can't determine relevant scheme, ambiguous context");
                 scheme = __schemes.at(context.getValueString());
         }
     }
 
     assert(scheme && "Context doesn't define any ad hoc scheme");
     return scheme;
 }
 
 const TypeAnnotation&
 AdhocScheme::getResultType(){
     return __resultType;
 }
 
 CodeScope*
 AdhocScheme::getCommandImplementation(const Expression& comm) {
     assert(comm.__state == Expression::COMPOUND && comm.op == Operator::CALL && comm.operands.size() == 0);
 
     const std::string commSerialized =  comm.getValueString();
     assert(__commands.count(commSerialized) && "Command isn't defined for a selected scheme");
     return __commands.at(commSerialized);
 }
 
 AdhocScheme::AdhocScheme(const Expression& scheme):
     __resultType(scheme.type), __name(scheme.getValueString()) {
 
     Expression exprCasesList = scheme.getOperands()[0];
     for (const Expression& exprSingleCase: exprCasesList.getOperands()){
         std::string command = exprSingleCase.tags.begin()->second.getValueString();
 
         CodeScope* blockImpl = *(exprSingleCase.blocks.begin());
         __commands.emplace(command, blockImpl);
     }
 }
 
 const std::string&
 AdhocScheme::getName(){
     return __name;
 }
 
 void
 AdhocPass::run(){
     queryContext = reinterpret_cast<context::ContextQuery*>(man->clasp->registerQuery(new context::ContextQuery(), QueryId::ContextQuery));
 
     auto range = man->root->__interfacesData.equal_range(ASTInterface::Adhoc);
     for (auto i=range.first; i!= range.second; ++i){
         AdhocScheme* scheme = new AdhocScheme(i->second);
         __schemes.emplace(scheme->getName(), scheme);
     }
 }
 
 }} //end of namespace xreate::adhoc
 
 
 
 
diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
index 8d094fa..4f49948 100644
--- a/cpp/src/pass/compilepass.cpp
+++ b/cpp/src/pass/compilepass.cpp
@@ -1,788 +1,791 @@
 #include "compilepass.h"
 #include "clasplayer.h"
 #include <ast.h>
 #include "llvmlayer.h"
 
 #include "query/containers.h"
 #include "query/context.h"
 #include "compilation/containers.h"
 #include "compilation/latecontextcompiler2.h"
 #include "ExternLayer.h"
 #include "pass/adhocpass.h"
 #include "compilation/targetinterpretation.h"
 #include "pass/versionspass.h"
 #include "compilation/scopedecorators.h"
 #include "compilation/adhocfunctiondecorator.h"
 #include "compilation/operators.h"
 #include "analysis/typeinference.h"
 
 #include <boost/optional.hpp>
 #include <memory>
 #include <iostream>
 
 using namespace std;
 using namespace llvm;
 
 //TODO use Scope<TargetLlvm>
 
     //SECTIONTAG late-context FunctionDecorator
 
 namespace xreate{namespace context{
 template<class Parent>
 class LateContextFunctionDecorator : public Parent {
 public:
     LateContextFunctionDecorator(ManagedFnPtr f, CompilePass* p)
     : Parent(f, p), contextCompiler(this, p) {
     }
 
 protected:
     std::vector<llvm::Type*> prepareArguments() {
         std::vector<llvm::Type*>&& arguments = Parent::prepareArguments();
 
         size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
         if (sizeLateContextDemand) {
             llvm::Type* ty32 = llvm::Type::getInt32Ty(llvm::getGlobalContext());
             llvm::Type* tyDemand = llvm::ArrayType::get(ty32, sizeLateContextDemand);
 
             arguments.push_back(tyDemand);
         }
 
         return arguments;
     }
 
     llvm::Function::arg_iterator prepareBindings() {
         llvm::Function::arg_iterator fargsI = Parent::prepareBindings();
 
         size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
         if (sizeLateContextDemand) {
             fargsI->setName("latecontext");
             contextCompiler.rawContextArgument = &*fargsI;
             ++fargsI;
         }
 
         return fargsI;
     }
 
 public:
     context::LateContextCompiler2 contextCompiler;
 };
 
 }} //end of namespace xreate::context
 
 namespace xreate { namespace compilation{
 
 std::string
 BasicFunctionUnit::prepareName(){
     AST* ast = IFunctionUnit::pass->man->root;
 
     string name = ast->getFunctionVariants(IFunctionUnit::function->__name).size() > 1 ?
             IFunctionUnit::function->__name + std::to_string(IFunctionUnit::function.id()) :
             IFunctionUnit::function->__name;
 
     return name;
 }
 
 std::vector<llvm::Type*>
 BasicFunctionUnit::prepareArguments() {
     LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
     AST* ast = IFunctionUnit::pass->man->root;
     CodeScope* entry = IFunctionUnit::function->__entry;
     std::vector<llvm::Type*> signature;
 
     std::transform(entry->__bindings.begin(), entry->__bindings.end(), std::inserter(signature, signature.end()),
             [llvm, ast, entry](const std::string & arg)->llvm::Type* {
                 assert(entry->__identifiers.count(arg));
 
                 ScopedSymbol argid{entry->__identifiers.at(arg), versions::VERSION_NONE};
                 return llvm->toLLVMType(ast->expandType(entry->__declarations.at(argid).type));
             });
 
     return signature;
 }
 
 llvm::Type*
 BasicFunctionUnit::prepareResult() {
     LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
     AST* ast = IFunctionUnit::pass->man->root;
     CodeScope* entry = IFunctionUnit::function->__entry;
 
     return llvm->toLLVMType(ast->expandType(entry->__declarations.at(ScopedSymbol::RetSymbol).type));
 }
 
 llvm::Function::arg_iterator
 BasicFunctionUnit::prepareBindings() {
     CodeScope* entry = IFunctionUnit::function->__entry;
     ICodeScopeUnit* entryCompilation = IFunctionUnit::getScopeUnit(entry);
     llvm::Function::arg_iterator fargsI = IFunctionUnit::raw->arg_begin();
 
     for (std::string &arg : entry->__bindings) {
         ScopedSymbol argid{entry->__identifiers[arg], versions::VERSION_NONE};
 
         entryCompilation->bindArg(&*fargsI, argid);
         fargsI->setName(arg);
         ++fargsI;
     }
 
     return fargsI;
 }
 
     //DEBT compiler rigidly depends on exact definition of DefaultFunctionUnit
 typedef context::LateContextFunctionDecorator<
         adhoc::AdhocFunctionDecorator<
         BasicFunctionUnit>> DefaultFunctionUnit;
 
 ICodeScopeUnit::ICodeScopeUnit(CodeScope* codeScope, IFunctionUnit* f, CompilePass* compilePass)
 : pass(compilePass), function(f), scope(codeScope) {
 }
 
 llvm::Value*
 CallStatementRaw::operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
     llvm::Function* calleeInfo = dyn_cast<llvm::Function>(__callee);
 
     if (calleeInfo) {
         auto argsFormal = calleeInfo->args();
 
         int pos = 0;
         //SECTIONTAG types/convert function ret value
         for (auto argFormal = argsFormal.begin(); argFormal != argsFormal.end(); ++argFormal, ++pos) {
             args[pos] = typeinference::doAutomaticTypeConversion(args[pos], argFormal->getType(), llvm->builder);
         }
     }
 
     return llvm->builder.CreateCall(__calleeTy, __callee, args, hintDecl);
 }
 
     //DESABLEDFEATURE implement inlining
 class CallStatementInline : public CallStatement {
 public:
     CallStatementInline(IFunctionUnit* caller, IFunctionUnit* callee, LLVMLayer* l)
     : __caller(caller), __callee(callee), llvm(l) {
     }
 
     llvm::Value* operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
         //TOTEST inlining
         //            CodeScopeUnit* entryCompilation = outer->getScopeUnit(function->__entry);
         //            for(int i=0, size = args.size(); i<size; ++i) {
         //                entryCompilation->bindArg(args.at(i), string(entryCompilation->scope->__bindings.at(i)));
         //            }
         //
         //
         //            return entryCompilation->compile();
 
         return nullptr;
     }
 
 private:
     IFunctionUnit* __caller;
     IFunctionUnit* __callee;
     LLVMLayer* llvm;
 
     bool isInline() {
         // Symbol ret = Symbol{0, function->__entry};
         // bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
         //TODO consider inlining
         return false;
     }
 };
 
 BasicCodeScopeUnit::BasicCodeScopeUnit(CodeScope* codeScope, IFunctionUnit* f, CompilePass* compilePass)
 : ICodeScopeUnit(codeScope, f, compilePass) {
 }
 
 llvm::Value*
 BasicCodeScopeUnit::processSymbol(const Symbol& s, std::string hintRetVar) {
     Expression declaration = CodeScope::getDeclaration(s);
     CodeScope* scope = s.scope;
     ICodeScopeUnit* self = ICodeScopeUnit::function->getScopeUnit(scope);
 
     return self->process(declaration, hintRetVar);
 }
 
 //SECTIONTAG late-context find callee function
 //TOTEST static late context decisions
 //TOTEST dynamic late context decisions
 CallStatement*
 BasicCodeScopeUnit::findFunction(const std::string& calleeName) {
     LLVMLayer* llvm = pass->man->llvm;
     ClaspLayer* clasp = pass->man->clasp;
     DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
     context::ContextQuery* queryContext = pass->queryContext;
 
     const std::list<ManagedFnPtr>& specializations = pass->man->root->getFunctionVariants(calleeName);
 
     //if no specializations registered - check external function
     if (specializations.size() == 0) {
         llvm::Function* external = llvm->layerExtern->lookupFunction(calleeName);
 
         llvm::outs() << "Debug/External function: " << calleeName;
         external->getType()->print(llvm::outs(), true);
         llvm::outs() << "\n";
 
         return new CallStatementRaw(external, llvm);
     }
 
     //no decisions required
     if (specializations.size() == 1) {
         if (!specializations.front()->guardContext.isValid()) {
             return new CallStatementRaw(pass->getFunctionUnit(specializations.front())->compile(), llvm);
         }
     }
 
     //TODO move dictSpecialization over to a separate function in order to perform cache, etc.
     //prepare specializations dictionary
     std::map<Expression, ManagedFnPtr> dictSpecializations;
 
     boost::optional<ManagedFnPtr> variantDefault;
     boost::optional<ManagedFnPtr> variant;
 
     for (const ManagedFnPtr& f : specializations) {
         const Expression& guard = f->guardContext;
 
         //default case:
         if (!guard.isValid()) {
             variantDefault = f;
             continue;
         }
 
         assert(dictSpecializations.emplace(guard, f).second && "Found several identical specializations");
     }
 
     //check static context
     ScopePacked scopeCaller = clasp->pack(this->scope);
     const string atomSpecialization = "specialization";
     const Expression topicSpecialization(Operator::CALL,{(Atom<Identifier_t>(string(atomSpecialization))),
         Expression(Operator::CALL,
         {Atom<Identifier_t>(string(calleeName))}),
         Atom<Number_t>(scopeCaller)});
 
     const context::Decisions& decisions = queryContext->getFinalDecisions(scopeCaller);
     if (decisions.count(topicSpecialization)) {
         variant = dictSpecializations.at(decisions.at(topicSpecialization));
     }
 
     //TODO check only demand for this particular topic.
     size_t sizeDemand = function->contextCompiler.getFunctionDemandSize();
 
     //decision made if static context found or no late context exists(and there is default variant)
     bool flagHasStaticDecision = variant || (variantDefault && !sizeDemand);
 
     //if no late context exists
     if (flagHasStaticDecision) {
         IFunctionUnit* calleeUnit = pass->getFunctionUnit(variant ? *variant : *variantDefault);
 
         //inlining possible based on static decision only
         //        if (calleeUnit->isInline()) {
         //            return new CallStatementInline(function, calleeUnit);
         //        }
 
         return new CallStatementRaw(calleeUnit->compile(), llvm);
     }
 
     //require default variant if no static decision made
     assert(variantDefault);
 
     llvm::Function* functionVariantDefault = this->pass->getFunctionUnit(*variantDefault)->compile();
     llvm::Value* resultFn = function->contextCompiler.findFunction(calleeName, functionVariantDefault, scopeCaller);
     llvm::PointerType *resultPTy = cast<llvm::PointerType>(resultFn->getType());
     llvm::FunctionType *resultFTy = cast<llvm::FunctionType>(resultPTy->getElementType());
     return new CallStatementRaw(resultFn, resultFTy, llvm);
 }
 
 
 
 //DISABLEDFEATURE transformations
 //    if (pass->transformations->isAcceptable(expr)){
 //        return pass->transformations->transform(expr, result, ctx);
 //    }
 
 llvm::Value*
 BasicCodeScopeUnit::process(const Expression& expr, const std::string& hintVarDecl) {
 #define DEFAULT(x) (hintVarDecl.empty()? x: hintVarDecl)
     llvm::Value *left;
     llvm::Value *right;
     LLVMLayer& l = *pass->man->llvm;
     xreate::compilation::Advanced instructions = xreate::compilation::Advanced({this, function, pass});
 
     switch (expr.op) {
         case Operator::SUB: case Operator::MUL:
         case Operator::DIV: case Operator::EQU: case Operator::LSS:
         case Operator::GTR: case Operator::NE: case Operator::LSE:
         case Operator::GTE:
 
             assert(expr.__state == Expression::COMPOUND);
             assert(expr.operands.size() == 2);
 
             left = process(expr.operands[0]);
             right = process(expr.operands[1]);
 
             //SECTIONTAG types/convert binary operation
             right = typeinference::doAutomaticTypeConversion(right, left->getType(), l.builder);
             break;
 
         default:;
     }
 
     switch (expr.op) {
         case Operator::ADD:
         {
             left = process(expr.operands[0]);
             Context context{this, function, pass};
 
             llvm::Value* resultSU = StructUpdate::add(expr.operands[0], left, expr.operands[1], context, DEFAULT("tmp_add"));
             if (resultSU) return resultSU;
 
             right = process(expr.operands[1]);
 
             llvm::Value* resultAddPA = pointerarithmetic::PointerArithmetic::add(left, right, context, DEFAULT("tmp_add"));
             if (resultAddPA) {
                 return resultAddPA;
             }
 
             return l.builder.CreateAdd(left, right, DEFAULT("tmp_add"));
             break;
         }
 
         case Operator::SUB:
             return l.builder.CreateSub(left, right, DEFAULT("tmp_sub"));
             break;
 
         case Operator::MUL:
             return l.builder.CreateMul(left, right, DEFAULT("tmp_mul"));
             break;
 
         case Operator::DIV:
             return l.builder.CreateSDiv(left, right, DEFAULT("tmp_div"));
             break;
 
         case Operator::EQU:
             if (left->getType()->isIntegerTy()) return l.builder.CreateICmpEQ(left, right, DEFAULT("tmp_equ"));
             if (left->getType()->isFloatingPointTy()) return l.builder.CreateFCmpOEQ(left, right, DEFAULT("tmp_equ"));
             break;
 
         case Operator::NE:
             return l.builder.CreateICmpNE(left, right, DEFAULT("tmp_ne"));
             break;
 
         case Operator::LSS:
             return l.builder.CreateICmpSLT(left, right, DEFAULT("tmp_lss"));
             break;
 
         case Operator::LSE:
             return l.builder.CreateICmpSLE(left, right, DEFAULT("tmp_lse"));
             break;
 
         case Operator::GTR:
             return l.builder.CreateICmpSGT(left, right, DEFAULT("tmp_gtr"));
             break;
 
         case Operator::GTE:
             return l.builder.CreateICmpSGE(left, right, DEFAULT("tmp_gte"));
             break;
 
         case Operator::NEG:
             left = process(expr.operands[0]);
             return l.builder.CreateNeg(left, DEFAULT("tmp_neg"));
             break;
 
         case Operator::CALL:
         {
             assert(expr.__state == Expression::COMPOUND);
 
             std::string nameCallee = expr.getValueString();
             shared_ptr<CallStatement> callee(findFunction(nameCallee));
 
             //prepare arguments
             std::vector<llvm::Value *> args;
             args.reserve(expr.operands.size());
 
             std::transform(expr.operands.begin(), expr.operands.end(), std::inserter(args, args.end()),
                 [this](const Expression & operand) {
                     return process(operand);
                 }
             );
 
             ScopePacked outerScopeId = pass->man->clasp->pack(this->scope);
 
             //TASK a) refactor CALL/ADHOC/find function
             //SECTIONTAG late-context propagation arg
             size_t calleeDemandSize = pass->queryContext->getFunctionDemand(nameCallee).size();
             if (calleeDemandSize) {
                 DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
                 llvm::Value* argLateContext = function->contextCompiler.compileContextArgument(nameCallee, outerScopeId);
                 args.push_back(argLateContext);
             }
 
             return (*callee)(move(args), DEFAULT("res_" + nameCallee));
         }
 
         case Operator::IF:
         {
             return instructions.compileIf(expr, DEFAULT("tmp_if"));
         }
 
         case Operator::SWITCH:
         {
             return instructions.compileSwitch(expr, DEFAULT("tmp_switch"));
         }
 
         case Operator::LOOP_CONTEXT:
         {
             assert(false);
             return nullptr;
             //return instructions.compileLoopContext(expr, DEFAULT("tmp_loop"));
         }
 
         case Operator::LOGIC_AND:
         {
             assert(expr.operands.size() == 1);
             return process(expr.operands[0]);
         }
 
         case Operator::LIST:
         {
             return instructions.compileListAsSolidArray(expr, DEFAULT("tmp_list"));
         };
 
         case Operator::LIST_RANGE:
         {
             assert(false); //no compilation phase for a range list
             //  return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
         };
 
         case Operator::LIST_NAMED:
         {
             typedef Expanded<TypeAnnotation> ExpandedType;
 
             ExpandedType tyStructLiteral = l.ast->getType(expr);
 
             const std::vector<string> fieldsFormal = (tyStructLiteral.get().__operator == TypeOperator::CUSTOM) ?
                     l.layerExtern->getStructFields(l.layerExtern->lookupType(tyStructLiteral.get().__valueCustom))
                     : tyStructLiteral.get().fields;
 
             std::map<std::string, size_t> indexFields;
             for (size_t i = 0, size = fieldsFormal.size(); i < size; ++i) {
                 indexFields.emplace(fieldsFormal[i], i);
             }
 
             llvm::StructType* tyLiteralRaw = llvm::cast<llvm::StructType>(l.toLLVMType(tyStructLiteral));
             llvm::Value* record = llvm::UndefValue::get(tyLiteralRaw);
 
             for (size_t i = 0; i < expr.operands.size(); ++i) {
                 const Expression& operand = expr.operands.at(i);
                 unsigned int fieldId = indexFields.at(expr.bindings.at(i));
 
                 llvm::Value* result = 0;
 
                 //TODO Null ad hoc llvm implementation (related code: operators/StructUpdate/add)
                 //                if (operand.isNone()){
                 //                    llvm::Type* tyNullField = tyRecord->getElementType(fieldId);
                 //                    result = llvm::UndefValue::get(tyNullField);
                 //
                 //                } else {
                 result = process(operand);
                 //                }
 
                 assert(result);
                 record = l.builder.CreateInsertValue(record, result, llvm::ArrayRef<unsigned>({fieldId}));
             }
 
             return record;
         };
 
         case Operator::MAP:
         {
             assert(expr.blocks.size());
             return instructions.compileMapSolidOutput(expr, DEFAULT("map"));
         };
 
         case Operator::FOLD:
         {
             return instructions.compileFold(expr, DEFAULT("fold"));
         };
 
         case Operator::FOLD_INF:
         {
             return instructions.compileFoldInf(expr, DEFAULT("fold"));
         };
 
         case Operator::INDEX:
         {
             //TODO allow multiindex
             assert(expr.operands.size() == 2);
             assert(expr.operands[0].__state == Expression::IDENT);
 
             const std::string& hintIdent = expr.operands[0].getValueString();
             Symbol s = Attachments::get<Symbol>(expr.operands[0]);
             const ExpandedType& t2 = pass->man->root->getType(expr.operands[0]);
 
             llvm::Value* aggr = processSymbol(s, hintIdent);
 
             switch (t2.get().__operator) {
                 case TypeOperator::STRUCT: case TypeOperator::CUSTOM:
                 {
                     std::string idxField;
                     const Expression& idx = expr.operands.at(1);
                     switch (idx.__state) {
 
                             //named struct field
                         case Expression::STRING:
                             idxField = idx.getValueString();
                             break;
 
                             //anonymous struct field
                         case Expression::NUMBER:
                             idxField = to_string((int) idx.getValueDouble());
                             break;
 
                         default:
                             assert(false && "Wrong index for a struct");
                     }
 
                     return instructions.compileStructIndex(aggr, t2, idxField);
                 };
 
                 case TypeOperator::ARRAY:
                 {
                     std::vector<llvm::Value*> indexes;
                     std::transform(++expr.operands.begin(), expr.operands.end(), std::inserter(indexes, indexes.end()),
                             [this] (const Expression & op) {
                                 return process(op);
                             }
                     );
 
                     return instructions.compileArrayIndex(aggr, indexes, DEFAULT(string("el_") + hintIdent));
                 };
 
                 default:
                     assert(false);
             }
         };
 
             //SECTIONTAG adhoc actual compilation
             //TODO a) make sure that it's correct: function->adhocImplementation built for Entry scope and used in another scope
         case Operator::ADHOC:
         {
             DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
             assert(function->adhocImplementation && "Adhoc implementation not found");
             const Expression& comm = adhoc::AdhocExpression(expr).getCommand();
 
             CodeScope* scope = function->adhocImplementation->getCommandImplementation(comm);
             ICodeScopeUnit* unitScope = function->getScopeUnit(scope);
 
             //SECTIONTAG types/convert ADHOC ret convertation
             llvm::Type* resultTy = l.toLLVMType(pass->man->root->expandType(function->adhocImplementation->getResultType()));
             return typeinference::doAutomaticTypeConversion(unitScope->compile(), resultTy, l.builder);
         };
 
         case Operator::CALL_INTRINSIC:
         {
             const std::string op = expr.getValueString();
 
             if (op == "copy") {
                 llvm::Value* result = process(expr.getOperands().at(0));
 
                 auto decoratorVersions = Decorators<VersionsScopeDecoratorTag>::getInterface(this);
                 llvm::Value* storage = decoratorVersions->processIntrinsicInit(result->getType());
                 decoratorVersions->processIntrinsicCopy(result, storage);
 
                 return l.builder.CreateLoad(storage, hintVarDecl);
             }
 
             assert(false && "undefined intrinsic");
         }
 
+        case Operator::VARIANT:
+        {
+            //TASK Variant compilation to implement
+            assert(false&& "Variant compilation not implemented yet");
+            return nullptr;
+//            const ExpandedType& typVariant = pass->man->root->getType(expr);
+//            llvm::Type* typRaw = l.toLLVMType(typVariant);
+//            int value = expr.getValueDouble();
+//            return llvm::ConstantInt::get(typRaw, value);
+        }
+
         case Operator::NONE:
             assert(expr.__state != Expression::COMPOUND);
 
             switch (expr.__state) {
                 case Expression::IDENT:
                 {
                     Symbol s = Attachments::get<Symbol>(expr);
                     return processSymbol(s, expr.getValueString());
                 }
 
                 case Expression::NUMBER:
                 {
                     llvm::Type* typConst;
 
                     if (expr.type.isValid()) {
                         typConst = l.toLLVMType(pass->man->root->getType(expr));
 
                     } else {
                         typConst = llvm::Type::getInt32Ty(llvm::getGlobalContext());
                     }
 
                     int literal = expr.getValueDouble();
                     return llvm::ConstantInt::get(typConst, literal);
                 }
 
                 case Expression::STRING:
                 {
                     return instructions.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
                 };
 
-                case Expression::VARIANT:
-                {
-                    const ExpandedType& typVariant = pass->man->root->getType(expr);
-                    llvm::Type* typRaw = l.toLLVMType(typVariant);
-                    int value = expr.getValueDouble();
-                    return llvm::ConstantInt::get(typRaw, value);
-                }
-
                 default:
                 {
                     break;
                 }
             };
 
             break;
 
         default: break;
 
     }
 
     assert(false && "Can't compile expression");
     return 0;
 }
 
 llvm::Value*
 BasicCodeScopeUnit::compile(const std::string& hintBlockDecl) {
     if (!hintBlockDecl.empty()) {
         llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm::getGlobalContext(), hintBlockDecl, function->raw);
         pass->man->llvm->builder.SetInsertPoint(block);
     }
 
     Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
     return processSymbol(symbScope);
 }
 
 ICodeScopeUnit::~ICodeScopeUnit() {
 }
 
 IFunctionUnit::~IFunctionUnit() {
 }
 
 llvm::Function*
 IFunctionUnit::compile() {
     if (raw != nullptr) return raw;
 
     LLVMLayer* llvm = pass->man->llvm;
     llvm::IRBuilder<>& builder = llvm->builder;
 
     string&& functionName = prepareName();
     std::vector<llvm::Type*>&& types = prepareArguments();
     llvm::Type* expectedResultType = prepareResult();
 
     llvm::FunctionType *ft = llvm::FunctionType::get(expectedResultType, types, false);
     raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(functionName, ft));
     prepareBindings();
 
     const std::string&blockName = "entry";
     llvm::BasicBlock* blockCurrent = builder.GetInsertBlock();
 
     llvm::Value* result = getScopeUnit(function->__entry)->compile(blockName);
     assert(result);
 
     //SECTIONTAG types/convert function ret value
     builder.CreateRet(typeinference::doAutomaticTypeConversion(result, expectedResultType, llvm->builder));
 
     if (blockCurrent) {
         builder.SetInsertPoint(blockCurrent);
     }
 
     llvm->moveToGarbage(ft);
     return raw;
 }
 
 ICodeScopeUnit*
 IFunctionUnit::getScopeUnit(CodeScope* scope) {
     if (__scopes.count(scope)) {
         auto result = __scopes.at(scope).lock();
 
         if (result) {
             return result.get();
         }
     }
 
     std::shared_ptr<ICodeScopeUnit> unit(pass->buildCodeScopeUnit(scope, this));
 
     if (scope->__parent != nullptr) {
         auto parentUnit = Decorators<CachedScopeDecoratorTag>::getInterface(getScopeUnit(scope->__parent));
         parentUnit->registerChildScope(unit);
 
     } else {
         __orphanedScopes.push_back(unit);
     }
 
     if (!__scopes.emplace(scope, unit).second) {
         __scopes[scope] = unit;
     }
 
     return unit.get();
 }
 
 ICodeScopeUnit*
 IFunctionUnit::getScopeUnit(ManagedScpPtr scope) {
     return getScopeUnit(&*scope);
 }
 
 ICodeScopeUnit*
 IFunctionUnit::getEntry() {
     return getScopeUnit(function->getEntryScope());
 }
 
 template<>
 compilation::IFunctionUnit*
 CompilePassCustomDecorators<void, void>::buildFunctionUnit(const ManagedFnPtr& function){
     return new DefaultFunctionUnit(function, this);
 }
 
 template<>
 compilation::ICodeScopeUnit*
 CompilePassCustomDecorators<void, void>::buildCodeScopeUnit(CodeScope* scope, IFunctionUnit* function){
     return new DefaultCodeScopeUnit(scope, function, this);
 }
 
 } // emf of compilation
 
 IFunctionUnit*
 CompilePass::getFunctionUnit(const ManagedFnPtr& function) {
     unsigned int id = function.id();
 
     if (!functions.count(id)) {
         IFunctionUnit* unit = buildFunctionUnit(function);
         functions.emplace(id, unit);
         return unit;
     }
 
     return functions.at(id);
 }
 
 void
 CompilePass::run() {
     managerTransformations = new TransformationsManager();
     targetInterpretation = new interpretation::TargetInterpretation(this->man->root, this);
     queryContext = reinterpret_cast<context::ContextQuery*> (man->clasp->getQuery(QueryId::ContextQuery));
 
     //Find out main function;
     ClaspLayer::ModelFragment model = man->clasp->query(Config::get("function-entry"));
     assert(model && "Error: No entry function found");
     assert(model->first != model->second && "Error: Ambiguous entry function");
 
     string nameMain = std::get<0>(ClaspLayer::parse<std::string>(model->first->second));
     IFunctionUnit* unitMain = getFunctionUnit(man->root->findFunction(nameMain));
     entry = unitMain->compile();
 }
 
 llvm::Function*
 CompilePass::getEntryFunction() {
     assert(entry);
     return entry;
 }
 
 void
 CompilePass::prepareQueries(ClaspLayer* clasp) {
     clasp->registerQuery(new containers::Query(), QueryId::ContainersQuery);
     clasp->registerQuery(new context::ContextQuery(), QueryId::ContextQuery);
 }
 } //end of namespace xreate
diff --git a/cpp/src/pass/interpretationpass.cpp b/cpp/src/pass/interpretationpass.cpp
index 69bb3b1..b1bc4d4 100644
--- a/cpp/src/pass/interpretationpass.cpp
+++ b/cpp/src/pass/interpretationpass.cpp
@@ -1,414 +1,413 @@
 /*
  * 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 "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::VARIANT:
         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::LIST:
         case Operator::LIST_NAMED: {
             for (const Expression &op: expression.getOperands()) {
                 resolution = unify(resolution, process(op, context));
             }
 
             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/types.cpp b/cpp/tests/types.cpp
index 1287263..8f0613f 100644
--- a/cpp/tests/types.cpp
+++ b/cpp/tests/types.cpp
@@ -1,165 +1,179 @@
 /*
  * types.cpp
  *
  *  Created on: Jun 4, 2015
  *      Author: pgess
  */
 
 #include "gtest/gtest.h"
 #include "xreatemanager.h"
 #include "llvmlayer.h"
 #include "main/Parser.h"
 
 using namespace std;
 using namespace xreate;
 using namespace xreate::grammar::main;
 
 TEST(Types, DependantTypes1) {
-	string&& code = "XmlNode = type alias {\n"
+	string&& code = "XmlNode = type {\n"
 			"        tag:: string,\n"
-			"       /* attrs:: [string],*/\n"
+			"        attrs:: [string], \n"
 			"        content:: string\n"
 			"}.\n";
 
 	std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
 	ExpandedType typeXmlNode = program->root->findType("XmlNode");
 
 	ASSERT_EQ(TypeOperator::STRUCT, typeXmlNode->__operator);
-	ASSERT_EQ(2, typeXmlNode->__operands.size());
+	ASSERT_EQ(3, typeXmlNode->__operands.size());
 	ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(0).__value);
-	ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(1).__value);
+        ASSERT_EQ(TypeOperator::ARRAY, typeXmlNode->__operands.at(1).__operator);
+	ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(2).__value);
 }
 
-TEST(Types, DependantTypes_FeatureTypeIndex_2) {
-	string&& code = "XmlNode = type alias {\n"
+TEST(Types, ast_ParameterizedTypes_FeatureTypeIndex_1) {
+	string&& code = "XmlNode = type {\n"
 			"        tag:: string,\n"
-			"       /* attrs:: [string],*/\n"
+			"        attrs:: [string],\n"
 			"        content:: string\n"
 			"}.\n"
 			""
-			"Template = type Template(Leaf) {Leaf, [Leaf[content]]}."
-			"Concrete = type alias Template(XmlNode).";
+			"Template = type(Leaf) {Leaf, [Leaf[content]]}."
+			"Concrete = type Template(XmlNode).";
 
 	std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
 	ExpandedType typeConcrete = program->root->findType("Concrete");
 
-
 	ASSERT_EQ(TypeOperator::STRUCT, typeConcrete->__operator);
 	ASSERT_EQ(2, typeConcrete->__operands.size());
 	ASSERT_EQ(TypeOperator::STRUCT, typeConcrete->__operands.at(0).__operator);
 
 	ASSERT_EQ(TypeOperator::ARRAY, typeConcrete->__operands.at(1).__operator);
 	ASSERT_EQ(TypePrimitive::String, typeConcrete->__operands.at(1).__operands.at(0).__value);
 }
 
 TEST(Types, TreeType1) {
-	string&& code = "XmlNode = type alias {\n"
+	string&& code = "XmlNode = type {\n"
 			"        tag:: string,\n"
-			"       /* attrs:: [string],*/\n"
+			"        attrs:: [string],\n"
 			"        content:: string\n"
 			"}.\n"
 			""
-			"Tree = type Tree(Leaf) {Leaf, [Tree(Leaf)]}."
-			"Concrete = type alias Tree(XmlNode).";
+			"Tree = type(Leaf) {Leaf, [Tree(Leaf)]}."
+			"Concrete = type Tree(XmlNode).";
 
 	std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
 	ExpandedType typeConcrete = program->root->findType("Concrete");
 
 	ASSERT_EQ(TypeOperator::STRUCT, typeConcrete->__operator);
 	ASSERT_EQ(2, typeConcrete->__operands.size());
 	ASSERT_EQ(TypeOperator::STRUCT, typeConcrete->__operands.at(0).__operator);
 
 	ASSERT_EQ(TypeOperator::ARRAY, typeConcrete->__operands.at(1).__operator);
 
 	auto typeLink = typeConcrete->__operands.at(1).__operands.at(0);
 	ASSERT_EQ(TypeOperator::LINK, typeLink.__operator);
 	ASSERT_EQ(typeConcrete->conjuctionId,typeLink.conjuctionId);
 }
 
 TEST(Types, TreeType1LLvm){
-	string&& code = "XmlNode = type alias {\n"
+	string&& code = "XmlNode = type {\n"
 			"        tag:: string,\n"
 			"       /* attrs:: [string],*/\n"
 			"        content:: string\n"
 			"}.\n"
 			""
-			"Tree = type Tree(Leaf) {Leaf, [Tree(Leaf)]}."
-			"Concrete = type alias Tree(XmlNode).";
+			"Tree = type(Leaf) {Leaf, [Tree(Leaf)]}."
+			"Concrete = type Tree(XmlNode).";
 
 	std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
 	ExpandedType typeConcrete = program->root->findType("Concrete");
 
 	llvm::Type* raw = program->llvm->toLLVMType(typeConcrete);
 }
 
 TEST(Types, ArrayOfExternal1){
     FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate","r");
     assert(input != nullptr);
 
     Scanner scanner(input);
     Parser parser(&scanner);
 
     parser.Parse();
     AST* ast = parser.root->finalize();
 
     CodeScope* body = ast->findFunction("test")->getEntryScope();
 
     const ExpandedType& t2 = ast->getType(body->getDeclaration(body->getSymbol("childrenRaw")));
     EXPECT_EQ(t2->__operator, TypeOperator::ARRAY);
 }
 
 TEST(Types, ExternType1){
 	FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate","r");
 	assert(input != nullptr);
 
 	Scanner scanner(input);
 	Parser parser(&scanner);
 	parser.Parse();
 
 	AST* ast = parser.root->finalize();
 	CodeScope* body = ast->findFunction("test")->getEntryScope();
 
     const ExpandedType& t2 = ast->getType(body->getDeclaration(body->getSymbol("tree")));
     EXPECT_EQ(t2->__operator, TypeOperator::CUSTOM);
 }
 
 TEST(Types, ast_VariantType1){
 	string&& code =
-			"	colors = type variant (RED, BLUE, GREEN).\n"
-			"	test = function:: colors; entry {GREEN}";
+        "	colors = type variant {RED, BLUE, GREEN}.\n"
+        "	test = function:: colors; entry {GREEN()}";
 
 	std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
 
 	ExpandedType typ = program->root->findType("colors");
 	EXPECT_EQ(TypeOperator::VARIANT, typ->__operator);
 
 	Expression eRed = program->root->findFunction("test")->getEntryScope()->getBody();
-	EXPECT_EQ(Expression::VARIANT, eRed.__state);
+	EXPECT_EQ(Operator::VARIANT, eRed.op);
 
 	const ExpandedType& typ2 = program->root->getType(eRed);
 	EXPECT_EQ(TypeOperator::VARIANT, typ2->__operator);
-
-	program->run();
 }
 
 TEST(Types, full_VariantType_Switch1){
 	string&& code =
-			"	colors = type variant (RED, BLUE, GREEN).   \n"
-			"	test = function:: colors {GREEN}            \n"
+			"	colors = type variant{RED, BLUE, GREEN}.   \n"
+			"	test = function:: colors {GREEN()}          \n"
 
 			"main = function:: int; entry {         \n"
 			"	switch(test()):: int    \n"
-			"	case (GREEN) {0}                  \n"
+			"	case (GREEN()) {0}                  \n"
 			"	case default {1}                \n"
 			"}";
 
 	XreateManager* man = XreateManager::prepare(move(code));
 	int (*main)() = (int (*)()) man->run();
 
 	EXPECT_EQ(0, main());
 }
 
+TEST(Types, ast_VariantType2){
+    std::string script=
+R"Code(
+    Expression = type
+        variant {
+            Num:: int,
+            String:: string,
+            Func:: {name::string, arguments::[Expression]}
+        }.
+)Code";
+
+    std::unique_ptr<XreateManager> program(XreateManager::prepare(move(script)));
+    ExpandedType typ = program->root->findType("Expression");
+    ASSERT_EQ(3, typ.get().fields.size());
+}
+
 //TEST(Types, A)
 
 
 //TOTEST string type