No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Dec 22, 3:25 PM

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/cpp/Configurations.cmake b/cpp/Configurations.cmake
	index be0d21d..34eec0c 100644
	--- a/cpp/Configurations.cmake
	+++ b/cpp/Configurations.cmake
	@@ -1,158 +1,160 @@
	cmake_minimum_required(VERSION 2.8.11)

	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -fprofile-arcs -ftest-coverage -O0")


	set(XREATE_DEFINITIONS_COMMON
	-D_GNU_SOURCE
	-D__STDC_CONSTANT_MACROS
	-D__STDC_FORMAT_MACROS
	-D__STDC_LIMIT_MACROS
	-DWITH_THREADS=1
	)
	#------------------------------------------------------
	# CONFIGURATION: Min

	set(XREATE_SOURCE_FILES_MIN
	+ compilation/resources.cpp
	analysis/typeinference.cpp
	xreatemanager.cpp
	transcendlayer.cpp
	llvmlayer.cpp
	pass/compilepass.cpp
	analysis/utils.cpp
	ast.cpp
	aux/xreatemanager-decorators.cpp
	compilation/transformations.cpp
	compilation/transformersaturation.cpp
	attachments.cpp
	compilation/control.cpp
	utils.cpp
	pass/abstractpass.cpp
	aux/serialization/expressionserializer.cpp
	analysis/transcendtarget.cpp analysis/resources.cpp
	query/containers.cpp
	modules.cpp
	compilation/containers.cpp
	compilation/containers/arrays.cpp
	)

	set(XREATE_TEST_FILES_MIN
	universal.cpp
	introduction.cpp
	unit-test-example.cpp
	supplemental/docutils
	transcend.cpp
	association.cpp
	main.cpp
	attachments.cpp
	ast.cpp
	compilation.cpp
	ExpressionSerializer.cpp
	types.cpp
	#vendorsAPI/clangAPI.cpp
	#vendorsAPI/xml2.cpp
	#vendorsAPI/json.cpp
	loops.cpp
	#supplemental/versions-algorithm-data_dependency.cpp
	supplemental/basics.cpp
	arithmetics.cpp
	)

	IF(XREATE_CONFIG STREQUAL "Min")
	set(XREATE_SOURCE_FILES
	${XREATE_SOURCE_FILES_MIN}
	)

	set(XREATE_TEST_FILES ${XREATE_TEST_FILES_MIN})

	set(XREATE_DEFINITIONS ${XREATE_DEFINITIONS_COMMON}
	-DXREATE_CONFIG_MIN
	)
	ENDIF()

	#------------------------------------------------------
	# CONFIGURATION: Default

	set(XREATE_SOURCE_FILES_DEFAULT ${XREATE_SOURCE_FILES_MIN}
	compilation/targetinterpretation.cpp
	analysis/temporalseqgraph.cpp
	pass/cfatemporalseqpass.cpp
	analysis/cfagraph.cpp
	pass/cfapass.cpp
	compilation/interpretation-instructions.cpp
	ExternLayer.cpp
	analysis/cfagraph.cpp
	compilation/latetranscend.cpp
	query/latex.cpp
	aux/latereasoning.cpp
	analysis/dfagraph.cpp
	pass/dfapass.cpp
	pass/interpretationpass.cpp
	pass/versionspass.cpp
	contextrule.cpp
	compilation/demand.cpp
	analysis/predefinedanns.cpp
	)

	set(XREATE_TEST_FILES_DEFAULT ${XREATE_TEST_FILES_MIN}
	interpretation.cpp
	transcend-ast.cpp
	cfa.cpp
	latetranscend.cpp
	latex.cpp
	polymorph.cpp
	virtualization.cpp
	exploitation.cpp
	effects-communication.cpp
	modules.cpp
	dfa.cpp
	effects-versions.cpp
	containers.cpp
	externc.cpp
	aux/expressions.cpp
	polymorphism-dt.cpp
	)

	IF(XREATE_CONFIG STREQUAL "Default")
	set(XREATE_SOURCE_FILES
	${XREATE_SOURCE_FILES_DEFAULT}
	)

	set(XREATE_TEST_FILES ${XREATE_TEST_FILES_DEFAULT})

	set(XREATE_DEFINITIONS ${XREATE_DEFINITIONS_COMMON}
	XREATE_ENABLE_EXTERN
	)
	ENDIF()

	#------------------------------------------------------
	# CONFIGURATION: Dimensions

	IF(XREATE_CONFIG STREQUAL "Dimensions")
	set(XREATE_SOURCE_FILES ${XREATE_SOURCE_FILES_MIN}
	+ compilation/lambdas.cpp
	query/demand.cpp
	compilation/demand.cpp
	query/polymorph.cpp
	compilation/polymorph.cpp
	aux/expressions.cpp
	pass/interpretationpass.cpp
	compilation/targetinterpretation.cpp
	compilation/intrinsics.cpp
	# compilation/containerinst.cpp
	analysis/predefinedanns.cpp
	analysis/typehints.cpp
	)

	set(XREATE_TEST_FILES ${XREATE_TEST_FILES_MIN}
	interpretation.cpp
	dimensions.cpp
	polymorph.cpp
	polymorphism-dt.cpp
	containers.cpp
	problems.cpp
	)

	set(XREATE_DEFINITIONS ${XREATE_DEFINITIONS_COMMON}
	-DXREATE_CONFIG_MIN
	)
	ENDIF()
	diff --git a/cpp/src/analysis/predefinedanns.cpp b/cpp/src/analysis/predefinedanns.cpp
	index 59812a2..e9ffcbb 100644
	--- a/cpp/src/analysis/predefinedanns.cpp
	+++ b/cpp/src/analysis/predefinedanns.cpp
	@@ -1,64 +1,75 @@
	//
	// Created by pgess on 19/03/2020.
	//

	#include "analysis/predefinedanns.h"

	namespace xreate{ namespace analysis{

	PredefinedAnns
	PredefinedAnns::__instance = PredefinedAnns();

	PredefinedAnns::PredefinedAnns(){
	fnAnnsT = TypeAnnotation(TypeOperator::VARIANT, {});
	exprAnnsT = TypeAnnotation(TypeOperator::VARIANT, {});

	//entry
	fnAnnsT.__operands.push_back(TypePrimitive::Invalid);
	fnAnnsT.fields.push_back("entry");

	//interpretation
	i12nModeT = TypeAnnotation(TypeOperator::VARIANT, {
	TypePrimitive::Invalid,
	TypePrimitive::Invalid
	});
	i12nModeT.fields.push_back("on");
	i12nModeT.fields.push_back("off");

	exprAnnsT.__operands.push_back(i12nModeT);
	exprAnnsT.fields.push_back("i12n");

	//Int
	hintsIntT = TypeAnnotation(TypeOperator::VARIANT, {
	TypePrimitive ::Int
	});
	hintsIntT.fields.push_back("size");

	//Containers
	hintsContT = TypeAnnotation(TypeOperator::VARIANT, {
	- TypePrimitive::Int
	+ TypePrimitive::Int,
	+ TypeAnnotation::alias("hintsContT")
	});
	hintsContT.fields.push_back("csize");
	+ hintsContT.fields.push_back("fly");
	}

	void
	-PredefinedAnns::fillRegistry(std::map<std::string, std::pair<TypeAnnotation, int>> &__registry) const{
	+PredefinedAnns::registerVariants(std::map<std::string, std::pair<TypeAnnotation, int>> &__registry) const{
	+ //annotation; type; variant id;
	__registry = {
	//Functions:
	{"entry", {fnAnnsT, (unsigned) FnAnnotations::ENTRY}},

	//Expressions:
	{"i12n", {exprAnnsT, (unsigned) ExprAnnotations::I12N}},

	//Interpretation:
	{"on", {i12nModeT, (unsigned) I12ModeTag::ON}},
	{"off", {i12nModeT, (unsigned) I12ModeTag::OFF}},

	//Int:
	{"size", {hintsIntT, (unsigned) IntHints::SIZE}},

	//Containers
	{"csize", {hintsContT, (unsigned) ContHints::ARRAY}},
	+ {"fly", {hintsContT, (unsigned) ContHints::FLY}},
	+ };
	+}
	+
	+void
	+PredefinedAnns::registerAliases(std::map<std::string, TypeAnnotation> &__registry) const{
	+ __registry = {
	+ {"hintsContT", hintsContT}
	};
	}
	}}
	\ No newline at end of file
	diff --git a/cpp/src/analysis/predefinedanns.h b/cpp/src/analysis/predefinedanns.h
	index 6d16e73..c860b32 100644
	--- a/cpp/src/analysis/predefinedanns.h
	+++ b/cpp/src/analysis/predefinedanns.h
	@@ -1,48 +1,49 @@
	//
	// Created by pgess on 19/03/2020.
	//

	#ifndef XREATE_PREDEFINEDANNS_H
	#define XREATE_PREDEFINEDANNS_H

	#include "ast.h"

	namespace xreate{ namespace analysis{
	class PredefinedAnns{
	public:
	enum class FnAnnotations{
	ENTRY
	};
	enum class ExprAnnotations{
	I12N
	};
	enum class I12ModeTag{
	ON, OFF
	};
	enum class IntHints{
	SIZE
	};

	enum class ContHints{
	- ARRAY
	+ ARRAY, FLY
	};

	TypeAnnotation fnAnnsT;
	TypeAnnotation exprAnnsT;
	TypeAnnotation hintsIntT;
	TypeAnnotation hintsContT;

	//Interpretation
	TypeAnnotation i12nModeT;

	PredefinedAnns();
	static const PredefinedAnns& instance(){ return __instance; }
	- void fillRegistry(std::map<std::string, std::pair<TypeAnnotation, int>> &__registry) const;
	+ void registerVariants(std::map<std::string, std::pair<TypeAnnotation, int>> &__registry) const;
	+ void registerAliases(std::map<std::string, TypeAnnotation>& __registry) const;

	private:
	static PredefinedAnns __instance;
	};

	}} // end of xreate::analysis

	#endif //XREATE_PREDEFINEDANNS_H
	diff --git a/cpp/src/analysis/typehints.cpp b/cpp/src/analysis/typehints.cpp
	index a0a6603..5c9c1e7 100644
	--- a/cpp/src/analysis/typehints.cpp
	+++ b/cpp/src/analysis/typehints.cpp
	@@ -1,52 +1,68 @@
	//
	// Created by pgess on 24/03/2020.
	//

	#include "analysis/typehints.h"
	#include "analysis/predefinedanns.h"
	#include "analysis/utils.h"

	namespace xreate{namespace typehints{

	namespace impl {
	template<class Hint>
	inline Hint getHint(const Expression& e, const Hint& def, unsigned annId, const ExpandedType& hintT){
	std::list<Expression> hintsL;
	auto predefined = analysis::PredefinedAnns::instance();
	for(const auto& tag: e.tags){hintsL.push_back(tag.second);}
	const Expression& hintActual = analysis::findAnnById(annId, hintT, hintsL);
	if (!hintActual.isValid()){
	return def;
	}

	return parse<Hint>(hintActual);
	}
	}

	-template<> IntBits parse(const Expression& e){
	+template<> IntBits
	+parse(const Expression& e){
	return {(unsigned) e.operands.at(0).getValueDouble()};
	}

	-template<> Array parse(const Expression& e){
	+template<> ArrayHint
	+parse(const Expression& e){
	return {(unsigned) e.operands.at(0).getValueDouble()};
	}

	-template<>
	-IntBits getHint(const Expression& e, const IntBits& def){
	+template<> FlyHint
	+parse(const Expression& e){
	+ return {e.operands.at(0)};
	+}
	+
	+template<> IntBits
	+find(const Expression& e, const IntBits& def){
	auto predefined = analysis::PredefinedAnns::instance();
	return impl::getHint<IntBits>(e, def,
	- (unsigned) analysis::PredefinedAnns::IntHints::SIZE,
	- ExpandedType(predefined.hintsIntT)
	+ (unsigned) analysis::PredefinedAnns::IntHints::SIZE,
	+ ExpandedType(predefined.hintsIntT)
	);
	}

	-template<>
	-Array getHint(const Expression& e, const Array& def){
	+template<> ArrayHint
	+find(const Expression& e, const ArrayHint& def){
	auto predefined = analysis::PredefinedAnns::instance();
	- return impl::getHint<Array>(e, def,
	- (unsigned) analysis::PredefinedAnns::ContHints::ARRAY,
	- ExpandedType(predefined.hintsContT)
	+ return impl::getHint<ArrayHint>(e, def,
	+ (unsigned) analysis::PredefinedAnns::ContHints::ARRAY,
	+ ExpandedType(predefined.hintsContT)
	);
	}

	+template<> FlyHint
	+find(const Expression& e, const FlyHint& def){
	+ auto predefined = analysis::PredefinedAnns::instance();
	+
	+ return impl::getHint<FlyHint>(e, def,
	+ (unsigned) analysis::PredefinedAnns::ContHints::FLY,
	+ ExpandedType(predefined.hintsContT));
	+}
	+
	}}
	\ No newline at end of file
	diff --git a/cpp/src/analysis/typehints.h b/cpp/src/analysis/typehints.h
	index 67028cc..33a7880 100644
	--- a/cpp/src/analysis/typehints.h
	+++ b/cpp/src/analysis/typehints.h
	@@ -1,46 +1,53 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* typehints.h
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file typehints.h
	* \brief Type inference hints
	*/
	#ifndef XREATE_TYPEHINTS_H
	#define XREATE_TYPEHINTS_H

	#include "ast.h"

	namespace xreate{namespace typehints{

	struct IntBits{
	unsigned int size;
	};

	-struct Array{
	+struct ArrayHint{
	size_t size;
	};

	+struct FlyHint{
	+ Expression hintSrc;
	+};
	+
	template<class Typ>
	-Typ getHint(const Expression& e, const Typ& def);
	+Typ find(const Expression& e, const Typ& def);
	+
	+template<>
	+IntBits find(const Expression& e, const IntBits& def);

	template<>
	-IntBits getHint(const Expression& e, const IntBits& def);
	+ArrayHint find(const Expression& e, const ArrayHint& def);

	template<>
	-Array getHint(const Expression& e, const Array& def);
	+FlyHint find(const Expression& e, const FlyHint& def);

	template<class Typ>
	Typ parse(const Expression& e);

	template<> IntBits parse(const Expression& e);
	-template<> Array parse(const Expression& e);
	+template<> ArrayHint parse(const Expression& e);

	}}

	#endif //XREATE_TYPEHINTS_H
	diff --git a/cpp/src/analysis/utils.cpp b/cpp/src/analysis/utils.cpp
	index a7e13bd..f932768 100644
	--- a/cpp/src/analysis/utils.cpp
	+++ b/cpp/src/analysis/utils.cpp
	@@ -1,425 +1,350 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* aux.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file src/analysis/utils.h
	* \brief Various reasoning related utilities
	*/

	#include "utils.h"
	#include "resources.h"
	#include <boost/format.hpp>

	using namespace std;

	namespace xreate { namespace analysis {

	-//std::list<std::string> multiplyLists(std::list<std::list<std::string>> &&lists){
	-// assert(false);
	-//}
	-//
	-//std::list<std::string>
	-//compile(const Expression &e){
	-// list<string> result;
	-//
	-// switch (e.op) {
	-// case Operator::CALL: {
	-//
	-// }
	-//
	-// case Operator::NEG: {
	-// assert(e.operands.size() == 1);
	-//
	-// const Expression &op = e.operands.at(0);
	-// list<string> &&rawOp = compile(op);
	-//
	-// assert(rawOp.size() == 1);
	-// result.push_back((boost::format("not %1%")%(rawOp.front())).str());
	-// break;
	-// };
	-//
	-// case Operator::INVALID: {
	-// switch (e.__state) {
	-// case Expression::IDENT:
	-// result.push_back(e.getValueString());
	-// break;
	-//
	-// case Expression::NUMBER:
	-// result.push_back(to_string(e.getValueDouble()));
	-// break;
	-//
	-// default:
	-// assert(true);
	-// }
	-// break;
	-// }
	-//
	-// default: break;
	-// }
	-//
	-// assert(result.size());
	-// return result;
	-//}
	-//
	-//std::list<std::string>
	-//compileNeg(const Expression &e){
	-// list<string> result;
	-// switch (e.op) {
	-// case Operator::IMPL: {
	-// assert(e.__state == Expression::COMPOUND);
	-// assert(e.operands.size() == 2);
	-// list<string> operands1 = compile(e.operands.at(0));
	-// list<string> operands2 = compile(e.operands.at(1));
	-//
	-// boost::format formatNeg("%1%, not %2%");
	-// for (const auto &op1: operands1)
	-// for (const auto &op2: operands2) {
	-// result.push_back(boost::str(formatNeg %(op1) % (op2)));
	-// }
	-// break;
	-// }
	-// case Operator::NEG: {
	-// assert(e.operands.size() == 1);
	-//
	-// const Expression &op = e.operands.at(0);
	-// list<string> &&rawOp = compile(op);
	-//
	-// assert(rawOp.size() == 1);
	-// result.push_back(rawOp.front());
	-// break;
	-// };
	-//
	-// default:
	-// assert(true);
	-// }
	-//
	-// return result;
	-//}
	-//
	-////NOTE: Any changes should be reflected in ParseImplAtom<SymbolPacked>,
	-//// ParseImplAtom<SymbolNode>
	-//class VisitorFormatSymbol: public boost::static_visitor<boost::format> {
	-//public:
	-//
	-// boost::format operator()(const SymbolPacked& node) const {
	-// boost::format formatSymbNamed("s(%1%,%2%,%3%)");
	-// return formatSymbNamed % node.identifier % node.version % node.scope ;
	-// }
	-//
	-// boost::format operator()(const SymbolAnonymous& node) const {
	-// boost::format formatSymbAnonymous("a(%1%)");
	-// return formatSymbAnonymous % node.id;
	-// }
	-//};
	-//
	-//boost::format writeSymbolNode(const SymbolNode& symbol){
	-// return boost::apply_visitor(VisitorFormatSymbol(), symbol);
	-//}
	-
	typedef vector<int> InstancePacked;

	std::list<Expression>
	generateAllInstancesInDomain2(const ExpandedType& domainT) {
	if(!domainT->isValid()) {
	return {Expression()};
	}
	assert(domainT->__operator == TypeOperator::VARIANT);
	std::list<Expression> results;
	int variantId = -1;

	bool flagDomainStateless = std::all_of(domainT->__operands.begin(), domainT->__operands.end(),
	[](const TypeAnnotation & subdomainT) {
	return !subdomainT.isValid();
	});

	for(const TypeAnnotation& subdomainT : domainT->__operands) {
	++variantId;

	if(flagDomainStateless) {
	Expression result(Operator::VARIANT,{});
	result.setValueDouble(variantId);
	results.push_back(result);
	continue;
	}

	std::list<Expression> subresults = generateAllInstancesInDomain2(ExpandedType(subdomainT));
	for (const Expression& subresult : subresults) {
	Expression result(Operator::VARIANT,{});
	result.setValueDouble(variantId);
	result.operands.push_back(subresult);

	results.push_back(result);
	}
	}

	return results;
	}

	TypeAnnotation
	collapseFnGroup(const std::list<Gringo::Symbol>& symbols) {
	Gringo::Symbol symbolAny = symbols.front();
	size_t operandsCount = symbolAny.args().size;

	TypeAnnotation resultT;
	resultT.__operands.reserve(operandsCount);

	for(size_t operandId = 0; operandId < operandsCount; ++operandId) {
	std::list<Gringo::Symbol> column;

	for(const Gringo::Symbol& row : symbols) {
	column.push_back(row.args()[operandId]);
	}

	TypeAnnotation operandT = collapseColumn(column);
	resultT.__operands.push_back(operandT);
	}

	if(resultT.__operands.size() == 1) {
	return resultT.__operands.front();
	}

	if(resultT.__operands.size() > 1) {
	resultT.__operator = TypeOperator::RECORD;
	return resultT;
	}

	return resultT;
	}

	TypeAnnotation
	collapseColumn(const std::list<Gringo::Symbol>& symbols) {
	TypeAnnotation resultT;
	if(!symbols.size()) return resultT;

	Gringo::Symbol symbolAny = symbols.front();

	switch(symbolAny.type()) {
	case Gringo::SymbolType::Num:
	{
	return TypeAnnotation(TypePrimitive::Int);
	}

	case Gringo::SymbolType::Str:
	{
	return TypeAnnotation(TypePrimitive::String);
	}

	case Gringo::SymbolType::Fun:
	{
	map<string, list < Gringo::Symbol>> fnGroups;

	for(const Gringo::Symbol& row : symbols) {
	fnGroups[row.name().c_str()].push_back(row);
	}

	TypeAnnotation resultT;
	resultT.__operands.reserve(fnGroups.size());
	resultT.bindings.reserve(fnGroups.size());

	for(const auto& group : fnGroups) {
	if(!group.second.size()) continue;

	TypeAnnotation variantT = collapseFnGroup(group.second);
	Gringo::Symbol symbolAny = group.second.front();
	string variantName = symbolAny.name().c_str();
	resultT.fields.push_back(variantName);
	resultT.__operands.push_back(variantT);
	}

	resultT.__operator = TypeOperator::VARIANT;
	// if(resultT.__operands.size() == 1) {
	// return resultT.__operands.front();
	// }
	return resultT;
	}

	case Gringo::SymbolType::Inf:
	case Gringo::SymbolType::Special:
	case Gringo::SymbolType::Sup:
	{
	break;
	}
	}

	assert(false);
	return TypeAnnotation();
	}

	ExpandedType
	dereferenceSlaveType(ExpandedType t, const TranscendLayer* transcend) {
	assert(t->__operator == TypeOperator::SLAVE);
	const string& domain = t->__valueCustom;
	StaticModel model = transcend->query(domain);
	if(!model.size()) return ExpandedType(TypeAnnotation());

	std::list<Gringo::Symbol> symbols;
	for(auto row : model) {
	symbols.push_back(row.second);
	}
	return ExpandedType(collapseFnGroup(symbols));
	}

	ASTSitePacked
	getSite(const Expression& e, TranscendLayer* transcend){
	Attachments::put<ExprId_A>(e, e);
	return transcend->pack(ASTSite{e.id});
	}

	Expression
	recognizeSite(const Gringo::Symbol& atom, const ExpandedType& schemaT, TranscendLayer* transcend)
	{
	if(atom.type()!=Gringo::SymbolType::Fun) return Expression();
	string predicateName = atom.name().c_str();
	if (predicateName != SITE_SYMBOL_PREDICATE && predicateName != SITE_ANON_PREDICATE)
	return Expression();

	const ASTSitePacked& siteP = TranscendLayer::parseAtom<ASTSitePacked>(atom);
	const ASTSite& site = transcend->unpack(siteP);
	return site.getDefinition();
	}

	Expression
	representTransExpression(const Gringo::Symbol& atom, ExpandedType schemaT, TranscendLayer* transcend) {
	const Expression siteExpr = recognizeSite(atom, schemaT, transcend);
	if (siteExpr.isValid()) return siteExpr;

	switch(schemaT->__operator) {
	case TypeOperator::NONE:
	{
	switch(schemaT->__value) {
	case TypePrimitive::I8:
	case TypePrimitive::I32:
	case TypePrimitive::I64:
	case TypePrimitive::Int:
	{
	return Expression(Atom<Number_t>(atom.num()));
	}

	case TypePrimitive::String:
	{
	return Expression(Atom<String_t>(atom.string().c_str()));
	}

	case TypePrimitive::Invalid:
	case TypePrimitive::Bool:
	case TypePrimitive::Float:
	{
	assert(false);
	return Expression();
	}
	}
	break;
	}

	case TypeOperator::SLAVE:
	{
	ExpandedType contentT = dereferenceSlaveType(schemaT, transcend);
	return representTransExpression(atom, contentT, transcend);
	}

	case TypeOperator::VARIANT:
	{
	map<string, int> dictVariants;
	for(size_t variantId = 0; variantId < schemaT->fields.size(); ++variantId) {
	dictVariants.emplace(schemaT->fields.at(variantId), variantId);
	}

	string predicateName = atom.name().c_str();
	assert(dictVariants.count(predicateName));

	size_t predicateId = dictVariants.at(predicateName);
	Expression result(Operator::VARIANT,{});
	result.op = Operator::VARIANT;
	result.setValueDouble(predicateId);

	if(!schemaT->__operands.size()) return result;
	ExpandedType schemeOperands = schemaT->__operands.at(predicateId).__operator == TypeOperator::SLAVE
	? dereferenceSlaveType(ExpandedType(schemaT->__operands.at(predicateId)), transcend)
	: ExpandedType(schemaT->__operands.at(predicateId));

	if (schemeOperands->__operator == TypeOperator::RECORD){
	Expression operandsList = representTransExpression(atom, schemeOperands, transcend);
	result.operands = move(operandsList.operands);

	} else if(!schemeOperands->isValid()) {
	assert(atom.args().size == 0);
	return result;

	} else {
	assert(false);
	}

	return result;
	}

	case TypeOperator::RECORD:
	{
	const Gringo::SymSpan& operandsRaw = atom.args();
	size_t opCount = operandsRaw.size;
	assert(opCount == schemaT->__operands.size());

	size_t operandId = 0;
	std::vector<Expression> operands;
	operands.reserve(opCount);
	for(const TypeAnnotation operandT : schemaT->__operands) {
	operands.push_back(representTransExpression(operandsRaw[operandId], ExpandedType(operandT), transcend));
	++operandId;
	}

	Expression result(Operator::LIST,{});
	result.operands = operands;
	- result.type = schemaT;
	+ result.type = schemaT.get();
	return result;
	}

	case TypeOperator::ARRAY:
	case TypeOperator::ALIAS:
	case TypeOperator::ACCESS:
	case TypeOperator::REF:
	case TypeOperator::VOID:
	case TypeOperator::GUARD:
	{
	assert(false);
	return Expression();
	}
	}

	assert(false);
	return Expression();
	}

	Expression
	representVecStr(const std::vector<std::string>& srcList){
	Expression dstE(Operator::LIST, {});

	for(const string op: srcList){
	dstE.operands.push_back(Atom<String_t>(string(op)));
	}

	return dstE;
	}

	Expression
	findAnnById(unsigned annId, const ExpandedType& annT, const std::list<Expression>& annotations){
	assert(annT->fields.size() > annId);
	const string& annExpectedS = annT->fields.at(annId);

	for(const Expression& e: annotations){
	if (e.type.fields.size() <= annId) continue;
	const string& annTestS = e.type.fields.at(annId);

	if (annTestS == annExpectedS) return e;
	}

	return Expression();
	}

	+Expression
	+findAnnByType(const Expression &expr, const ExpandedType &annExpectedT, AST *ast){
	+ std::list<Expression> tagsL;
	+ for(const auto& tag: expr.tags){tagsL.push_back(tag.second);}
	+
	+ for (const Expression& annActualE: tagsL){
	+ if (isSameVariantType(ast->expandType(annActualE.type), annExpectedT)){
	+ return annActualE;
	+ }
	+ }
	+
	+ return Expression();
	+}
	+
	+bool
	+isSameVariantType(const ExpandedType& a, const ExpandedType& b){
	+ assert(a->__operator == TypeOperator::VARIANT);
	+ assert(b->__operator == TypeOperator::VARIANT);
	+
	+ if (a->fields.size()!= b->fields.size()) return false;
	+ for (size_t idx = 0; idx < a->fields.size(); ++idx){
	+ if (a->fields.at(idx) != b->fields.at(idx)) return false;
	+ }
	+
	+ return true;
	+}
	+
	}} //end of xreate::analysis


	diff --git a/cpp/src/analysis/utils.h b/cpp/src/analysis/utils.h
	index c47a0ee..584d3b8 100644
	--- a/cpp/src/analysis/utils.h
	+++ b/cpp/src/analysis/utils.h
	@@ -1,59 +1,61 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: aux.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 26, 2016, 6:49 PM
	*/

	#ifndef AUX_H
	#define AUX_H

	#include "ast.h"
	#include "transcendlayer.h"

	#include <list>
	#include <boost/format.hpp>

	namespace xreate { namespace analysis {

	/**
	* \brief Compiles Xreate expression into ASP format recognizable by an external ASP solver.
	* @param e expression
	* @return textual expression's representation in an ASP format.
	*/
	std::list<std::string> compile(const Expression &e);
	std::list<std::string> compileNeg(const Expression &e);
	std::list<std::string> multiplyLists(std::list<std::list<std::string>> &&lists);

	ASTSitePacked getSite(const Expression& e, TranscendLayer* transcend);

	/**
	* \brief Converts a Transcend's fact to a Xreate's expression that can be interpreted further. Supports `query` keyword.
	* @param atom Transcend's fact
	* @param schemaT Type of the resulting expression
	* @param transcend Transcend's instance
	* @return converted Transcend' fact in form of Xreate's expression
	*/
	Expression representTransExpression(const Gringo::Symbol& atom, ExpandedType schemaT, TranscendLayer* transcend);

	/**
	* \brief Expands slave type.
	* @param t Slave type
	* @param transcend Instance of Transcend
	* @return The expanded slave type
	*/
	ExpandedType dereferenceSlaveType(ExpandedType t, const TranscendLayer* transcend);

	TypeAnnotation collapseColumn(const std::list<Gringo::Symbol>& symbols);
	std::list<Expression> generateAllInstancesInDomain2(const ExpandedType& domainT);

	Expression representVecStr(const std::vector<std::string>& srcList);
	Expression findAnnById(unsigned annId, const ExpandedType& annT, const std::list<Expression>& annotations);
	+Expression findAnnByType(const Expression &expr, const ExpandedType &annExpectedT, AST *ast);
	+bool isSameVariantType(const ExpandedType& a, const ExpandedType& b);

	}} //end of xreate::analysis

	#endif /* AUX_H */

	diff --git a/cpp/src/ast.cpp b/cpp/src/ast.cpp
	index fd5eaec..d53ea10 100644
	--- a/cpp/src/ast.cpp
	+++ b/cpp/src/ast.cpp
	@@ -1,961 +1,964 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: ast.cpp
	*/

	#include "ast.h"
	#include "analysis/typeinference.h"
	#include "analysis/predefinedanns.h"

	#ifdef XREATE_ENABLE_EXTERN
	#include "ExternLayer.h"
	#endif

	#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));
	}

	Atom<String_t>::Atom(std::string && name) : __value(name) {}

	const std::string&
	Atom<String_t>::get() const {
	return __value;
	}

	/** \brief xreate::Expression static information*/
	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:
	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:
	return true;

	case Expression::INVALID:
	assert(false);

	case Expression::IDENT:
	case Expression::STRING:
	case Expression::BINDING:
	return false;

	case Expression::COMPOUND: {
	switch (e.op) {
	case Operator::VARIANT:
	return true;
	default: return false;
	}
	}
	}

	return false;
	}
	};

	class TypeResolver {
	public:
	TypeResolver(const AST* ast,
	TypeResolver * parent,
	std::set<std::string> trace,
	const std::map<std::string, TypeAnnotation>& scope = std::map<std::string, TypeAnnotation>())
	: __ast(ast), __scope(scope), __trace(trace), __parent(parent) {}

	ExpandedType
	operator()(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) {
	- //assert(args.size() == t.bindings.size()); // invalid number of arguments
	+ 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 = this->operator()(t.__operands.at(0));
	- return ExpandedType(TypeAnnotation(TypeOperator::ARRAY, {elTy}));
	+ return ExpandedType(TypeAnnotation(TypeOperator::ARRAY, {elTy.get()}));
	}

	case TypeOperator::RECORD:
	{
	std::vector<TypeAnnotation>&& packOperands = expandOperands(t.__operands);
	auto typNew = TypeAnnotation(TypeOperator::RECORD, move(packOperands));
	typNew.fields = t.fields;

	return ExpandedType(move(typNew));
	};

	case TypeOperator::VARIANT:
	{
	std::vector<TypeAnnotation>&& packOperands = expandOperands(t.__operands);
	auto typNew = TypeAnnotation(TypeOperator::VARIANT, move(packOperands));
	typNew.fields = t.fields;

	return ExpandedType(move(typNew));
	};

	case TypeOperator::ALIAS: {
	std::string alias = t.__valueCustom;
	if (__trace.count(alias)){
	assert(false && "Recursive Type");
	return ExpandedType(TypeAnnotation());
	}

	const TypeAnnotation& tyAlias = findType(alias);
	std::vector<TypeAnnotation>&& operands = expandOperands(t.__operands);
	auto traceNew =__trace;
	traceNew.insert(alias);
	return TypeResolver(__ast, this, traceNew, __scope)(tyAlias, operands);
	};

	case TypeOperator::ACCESS:
	{
	std::string alias = t.__valueCustom;
	const TypeAnnotation& ty = findType(alias);
	- TypeAnnotation tyAggr = this->operator()(ty);
	+ TypeAnnotation tyAggr = this->operator()(ty).get();

	for (const string& field : t.fields) {
	auto fieldIt = std::find(tyAggr.fields.begin(), tyAggr.fields.end(), field);
	assert(fieldIt != tyAggr.fields.end() && "unknown field");

	int fieldId = fieldIt - tyAggr.fields.begin();
	tyAggr = tyAggr.__operands.at(fieldId);
	}

	return ExpandedType(tyAggr);
	}

	case TypeOperator::NONE:
	case TypeOperator::VOID:
	case TypeOperator::SLAVE:
	case TypeOperator::REF: {
	return ExpandedType(t);
	}

	default:
	assert(false);
	}

	assert(false);
	return ExpandedType(TypeAnnotation());
	}

	private:
	const AST* __ast;
	std::map<std::string, TypeAnnotation> __scope;
	std::set<std::string> __trace;
	TypeResolver* __parent;

	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 this->operator()(t);
	+ return this->operator()(t).get();
	});
	return pack;
	}

	TypeAnnotation findType(const std::string& alias){
	if (__scope.count(alias)) {
	return __scope.at(alias);

	} else if (__parent){
	return __parent->findType(alias);

	} else if (__ast->__registryTypes.count(alias)){
	return __ast->__registryTypes.at(alias);
	}

	assert(false && "Undefined or external type");
	return 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) {
	}

	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::ALIAS \|\| __operator == TypeOperator::ACCESS) {
	if (__valueCustom != t.__valueCustom)
	return __valueCustom < t.__valueCustom;
	}

	return __operands < t.__operands;
	}

	-/*
	-TypeAnnotation (struct_tag, std::initializer_list<TypeAnnotation>)
	-{}
	- */
	+TypeAnnotation
	+TypeAnnotation::alias(const std::string& alias)
	+{
	+
	+}

	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::INVALID;
	__valueD = number.get();
	}

	Expression::Expression(const Atom<String_t>& a)
	: Expression() {
	__state = STRING;
	op = Operator::INVALID;
	__valueS = a.get();
	}

	Expression::Expression(const Atom<Identifier_t> &ident)
	: Expression() {
	__state = IDENT;
	op = Operator::INVALID;
	__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::INVALID:
	__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 && __state != INVALID);
	}

	Expression::Expression()
	: __state(INVALID), op(Operator::INVALID), id(nextVacantId++) {
	}

	namespace details { namespace inconsistent {

	std::map<std::string, IntrinsicFn>
	AST::__registryIntrinsics = {};

	AST::AST() {
	Attachments::init<versions::VariableVersion>();
	Attachments::init<IdentifierSymbol>();
	Attachments::init<ExprAlias_A>();
	Attachments::init<TypeInferred>();
	Attachments::init<ExprId_A>();

	initIntrinsics();
	- analysis::PredefinedAnns::instance().fillRegistry(__registryVariants);
	+ analysis::PredefinedAnns man = analysis::PredefinedAnns::instance();
	+ man.registerVariants(__registryVariants);
	+ man.registerAliases(__registryTypes);
	}

	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 &&entry) {
	//__externdata.push_back(entry);
	}

	void
	AST::add(Function* f) {
	__functions.push_back(f);
	__dictFunctions.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) {
	__registryVariants.emplace(t.fields[i], make_pair(t, i));
	}
	}

	__registryTypes.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";
	+ const std::string name = "main";

	return name;
	}

	ManagedPtr<Function>
	AST::findFunction(const std::string& name) {
	int count = __dictFunctions.count(name);
	if (!count) {
	return ManagedFnPtr::Invalid();
	}

	assert(count == 1);

	auto range = __dictFunctions.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::getFnSpecializations(const std::string& fnName) const {
	auto functions = __dictFunctions.equal_range(fnName);

	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);
	}

	void
	AST::recognizeIntrinsic(Expression& fn) const {
	assert(fn.op == Operator::CALL_INTRINSIC);
	if (!__registryIntrinsics.count(fn.getValueString())){
	assert(false);
	}

	IntrinsicFn fnCode = __registryIntrinsics.at(fn.getValueString());
	fn.op = Operator::CALL_INTRINSIC;
	fn.setValueDouble((int) fnCode);
	}

	bool
	AST::recognizeVariantConstructor(Expression& function) {
	assert(function.op == Operator::CALL);
	std::string variant = function.getValueString();
	if (!__registryVariants.count(variant)) {
	return false;
	}

	auto record = __registryVariants.at(variant);
	const TypeAnnotation& typ = record.first;

	function.op = Operator::VARIANT;
	function.setValueDouble(record.second);
	function.type = typ;
	return true;
	}

	Atom<Number_t>
	AST::recognizeVariantConstructor(Atom<Identifier_t> ident) {
	std::string variant = ident.get();
	assert(__registryVariants.count(variant) && "Can't recognize variant constructor");
	auto record = __registryVariants.at(variant);

	return Atom<Number_t>(record.second);
	}

	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 identifier: " << identifier.second.getValueString() << std::endl;
	assert(false && "Unknown identifier");
	}
	}
	}

	xreate::AST*
	AST::finalize() {
	//all finalization steps:
	recognizePostponedIdentifiers();

	return reinterpret_cast<xreate::AST*> (this);
	}

	void
	AST::initIntrinsics(){
	if (__registryIntrinsics.size()) return;

	__registryIntrinsics = {
	{"array_init", IntrinsicFn::ARR_INIT},
	{"rec_fields", IntrinsicFn::REC_FIELDS}
	};
	}
	} } //namespace details::incomplete

	Expanded<TypeAnnotation>
	AST::findType(const std::string& name) {
	// find in general scope:
	if (__registryTypes.count(name))
	return expandType(__registryTypes.at(name));

	//if type is unknown keep it as is.
	TypeAnnotation t(TypeOperator::ALIAS, {});
	t.__valueCustom = name;
	return ExpandedType(move(t));
	}

	Expanded<TypeAnnotation>
	AST::expandType(const TypeAnnotation &t) const {
	return TypeResolver(this, nullptr, {}, {})(t);
	}

	ExpandedType
	AST::getType(const Expression& e, const TypeAnnotation& expectedT) {
	return typeinference::getType(e, expectedT, *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, const VNameId hintBindingId) {
	__entry->addBinding(move(name), move(argument), hintBindingId);
	}

	const std::string&
	Function::getName() const {
	return __name;
	}

	ScopedSymbol
	CodeScope::registerIdentifier(const Expression& identifier, const VNameId hintBindingId) {
	versions::VariableVersion version = Attachments::get<versions::VariableVersion>(identifier, versions::VERSION_NONE);

	auto result = __identifiers.emplace(identifier.getValueString(), hintBindingId? hintBindingId: __identifiers.size() + 1);
	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<IdentifierSymbol>(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, const VNameId hintBindingId) {
	argument.__state = Expression::BINDING;

	__bindings.push_back(var.getValueString());
	ScopedSymbol binding = registerIdentifier(var, hintBindingId);
	__declarations[binding] = move(argument);
	}

	Symbol
	CodeScope::addDefinition(Expression&& var, Expression&& body) {
	ScopedSymbol s = registerIdentifier(var);
	__declarations[s] = move(body);

	return Symbol{s, this};
	}

	CodeScope::CodeScope(CodeScope* parent)
	: __parent(parent) {
	}

	CodeScope::~CodeScope() {
	}

	void
	CodeScope::setBody(const Expression &body) {
	assert(__declarations.count(ScopedSymbol::RetSymbol)==0 && "Attempt to reassign scope body");
	__declarations[ScopedSymbol::RetSymbol] = body;
	}

	const Expression&
	CodeScope::getBody() const{
	return __declarations.at(ScopedSymbol::RetSymbol);
	}

	const Expression&
	CodeScope::getDefinition(const Symbol& symbol, bool flagAllowUndefined){
	const CodeScope* self = symbol.scope;
	return self->getDefinition(symbol.identifier, flagAllowUndefined);
	}

	const Expression&
	CodeScope::getDefinition(const ScopedSymbol& symbol, bool flagAllowUndefined) const{
	static Expression expressionInvalid;

	if (!__declarations.count(symbol)){
	if (flagAllowUndefined) return expressionInvalid;
	assert(false && "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(TranscendLayer& 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 ASTSite& s1, const ASTSite& s2){
	return s1.id < s2.id;
	}

	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:
	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};

	Expression
	ASTSite::getDefinition() const{
	if (Attachments::exists<ExprAlias_A>(id)){
	const Symbol& siteS = Attachments::get<ExprAlias_A>(id);
	return CodeScope::getDefinition(siteS, true);
	}

	return Attachments::get<ExprId_A>(id);
	}
	} //end of namespace xreate




	diff --git a/cpp/src/ast.h b/cpp/src/ast.h
	index 4334ca8..06517c4 100644
	--- a/cpp/src/ast.h
	+++ b/cpp/src/ast.h
	@@ -1,750 +1,751 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: ast.h
	*/

	/**
	* \file ast.h
	* \brief A syntax tree representation and related code
	*
	* \sa xreate::AST
	*/

	#ifndef AST_H
	#define AST_H

	#include "attachments.h"
	#include "utils.h"

	#include <string>
	#include <list>
	#include <vector>
	#include <map>
	#include <set>
	#include <unordered_map>
	#include <unordered_set>
	#include <algorithm>
	#include <climits>

	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 store line:col for all atoms/identifiers
	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);
	Atom(std::string && name);
	const std::string& get() const;

	private:
	std::string __value;
	};

	enum class TypePrimitive {
	Invalid, Bool, I8, I32, I64, Int, Float, String
	};

	enum class TypeOperator {
	NONE, VOID, REF, ALIAS, VARIANT, ARRAY, RECORD, ACCESS, SLAVE, GUARD
	};

	struct struct_tag {
	};
	const struct_tag tag_struct = struct_tag();

	/**
	* \brief A type representation to support type system
	*
	* The class represents type in a denormalized form, i.e. with no arguments and aliases substitution
	* \sa AST::expandType()
	*/
	class TypeAnnotation {
	public:
	TypeAnnotation();
	TypeAnnotation(TypePrimitive typ);

	TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands);
	TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands);
	+ static TypeAnnotation alias(const std::string& alias);
	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;

	std::vector<std::string> fields;
	std::vector<std::string> bindings;
	private:
	};

	enum class Operator {
	INVALID, UNDEF, AND, OR, ADD, SUB, MUL, DIV, MOD,
	EQU, NE, NEG, LSS,
	LSE, GTR, GTE, LIST,
	LIST_INDEX, LIST_RANGE,
	CALL, CALL_INTRINSIC, QUERY, QUERY_LATE,
	IMPL/* implication */, MAP,
	FOLD, FOLD_INF, INDEX,
	IF, SWITCH, SWITCH_VARIANT, SWITCH_LATE,
	CASE, CASE_DEFAULT, LOGIC_AND,
	CONTEXT_RULE, VARIANT, SEQUENCE, UPDATE
	};

	class Function;
	class AST;
	class CodeScope;
	class MetaRuleAbstract;

	typedef ManagedPtr<Function> ManagedFnPtr;
	typedef ManagedPtr<CodeScope> ManagedScpPtr;
	typedef ManagedPtr<MetaRuleAbstract> ManagedRulePtr;
	const ManagedScpPtr NO_SCOPE = ManagedScpPtr(UINT_MAX, 0);

	/**
	* \brief AST node to represent a single instruction or an annotation
	* \attention In case of any changes update \ref xreate::ExpressionHints auxiliary helper as well
	*
	* %Expression is a generic building block of syntax tree which is able to hold node data
	* along with child nodes as operands.
	*
	* \note For types the %expression-like data structure \ref TypeAnnotation is used rather than Expression itself.
	* \sa xreate::AST, xreate::TypeAnnotation
	*/
	struct Expression {
	friend class CodeScope;
	friend class TranscendLayer;
	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;

	/**
	* \brief is it string, number, compound operation and so on
	*/
	enum {
	INVALID, COMPOUND, IDENT, NUMBER, STRING, BINDING
	} __state = INVALID;

	/**
	* \brief Valid for compound State. Holds type of compound operator
	*/
	Operator op;

	/**
	* \brief Unique id to identify expression within syntax tree
	*/
	unsigned int id;

	/**
	* \brief Exact meaning depends on particular instruction
	* \details As an example, named lists/structs hold field names in bindings
	*/
	std::vector<std::string> bindings;

	/**
	* \brief Holds child instructions as arguments
	*/
	std::vector<Expression> operands;

	/**
	* \brief Holds type of instruction's result
	*/
	TypeAnnotation type;

	/**
	* \brief Holds additional annotations
	*/
	mutable std::map<std::string, Expression> tags;

	/**
	* \brief Child code blocks
	* \details For example, If statement holds TRUE-branch as first and FALSE-branch as second block here
	*/
	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();
	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 TranscendLayer;
	class LLVMLayer;

	class MetaRuleAbstract {
	public:
	MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards);
	virtual ~MetaRuleAbstract();
	virtual void compile(TranscendLayer& layer) = 0;
	protected:
	RuleArguments __args;
	RuleGuards __guards;
	};

	class RuleWarning : public MetaRuleAbstract {
	friend class TranscendLayer;
	public:
	RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message);
	virtual void compile(TranscendLayer& 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;
	const CodeScope * scope;
	};

	struct ASTSite {
	unsigned int id;

	Expression getDefinition() const;
	//static Ast registerSite(const Expression& e);
	};

	struct IdentifierSymbol{};
	struct ExprAlias_A{};
	struct ExprId_A{};

	template<>
	struct AttachmentsDict<IdentifierSymbol> {
	typedef Symbol Data;
	static const unsigned int key = 7;
	};

	template<>
	struct AttachmentsDict<ExprAlias_A> {
	typedef Symbol Data;
	static const unsigned int key = 9;
	};

	template<>
	struct AttachmentsDict<ExprId_A>{
	typedef Expression Data;
	static const unsigned int key = 12;
	};

	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);
	bool operator< (const ASTSite& s1, const ASTSite& s2);

	/**
	* \brief AST node to represent a single code block/a scope of visibility
	*
	* Holds a single expression as a `body` along with set of variable assignments(declarations) used in body's expression.
	* \sa xreate::AST
	*/
	class CodeScope {
	friend class Function;
	friend class PassManager;

	public:
	CodeScope(CodeScope* parent = 0);
	~CodeScope();

	/** \brief Set expression as a body */
	void setBody(const Expression& body);

	/** \brief Returns current code scope body */
	const Expression& getBody() const;

	/** \brief Adds variable definition to be used in body as well as in other declarations */
	Symbol addDefinition(Expression&& var, Expression&& body);

	/** \brief Returns symbols' definition */
	static const Expression& getDefinition(const Symbol& symbol, bool flagAllowUndefined = false);
	const Expression& getDefinition(const ScopedSymbol& symbol, bool flagAllowUndefined = false) const;

	/** \brief Adds variable defined elsewhere */
	void addBinding(Expression&& var, Expression&& argument, const VNameId hintBindingId = 0);

	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 index 0
	std::unordered_map<ScopedSymbol, Expression> __declarations;
	std::vector<Expression> tags;
	std::vector<Expression> contextRules;

	private:
	ScopedSymbol registerIdentifier(const Expression& identifier, const VNameId hintBindingId = 0);

	public:
	bool recognizeIdentifier(const Expression& identifier) const;
	ScopedSymbol getSymbol(const std::string& alias);
	};

	/**
	* \brief AST node to represent a single function
	*
	* Holds an `__entry` entry code scope along with `guard` to denote the different specializations.
	* \sa xreate::AST
	*/
	class Function {
	friend class Expression;
	friend class CodeScope;
	friend class AST;

	public:
	Function(const Atom<Identifier_t>& name);

	/**
	* \brief Adds function arguments
	*/
	void addBinding(Atom <Identifier_t>&& name, Expression&& argument, const VNameId hintBindingId=0);

	/**
	* \brief Adds additional function annotations
	*/
	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;
	Expression guard;

	private:
	std::map<std::string, Expression> __tags;
	};


	class ExternData;

	typedef Expanded<TypeAnnotation> ExpandedType;

	struct TypeInferred{};
	template<>
	struct AttachmentsDict<TypeInferred> {
	typedef ExpandedType Data;
	static const unsigned int key = 11;
	};

	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);
	}
	};

	template<>
	struct AttachmentsId<CodeScope*>{
	static unsigned int getId(const CodeScope* scope){
	const Symbol symbolScope{ScopedSymbol::RetSymbol, scope};
	return AttachmentsId<Symbol>::getId(symbolScope);
	}
	};

	template<>
	struct AttachmentsId<unsigned int>{
	static unsigned int getId(const unsigned int id){
	return id;
	}
	};

	class TypeResolver;

	enum class IntrinsicFn {
	ARR_INIT,
	REC_FIELDS
	};

	namespace details { namespace inconsistent {

	/**
	* \brief AST in an inconsistent form during construction
	*
	* Represents AST under construction(inconsistent state).
	* \attention Clients should use rather xreate::AST unless client's code explicitly works with Syntax Tree during construction.
	*
	* Typically an instance is created by xreate::XreateManager only and filled out by the parser
	* \sa xreate::XreateManager::prepare(std::string&&)
	*/
	class AST {
	friend class xreate::TypeResolver;
	public:
	AST();

	/**
	* \brief Adds new function to AST
	* \param f Function to register
	*/
	void add(Function* f);

	/**
	* \brief Adds new declarative rule to AST
	* \param r Declarative Rule
	*/
	void add(MetaRuleAbstract* r);

	/** \brief Registers new code block */
	ManagedScpPtr add(CodeScope* scope);

	/**
	* \brief Add new type to AST
	* @param t Type definition
	* @param alias Typer name
	*/
	void add(TypeAnnotation t, Atom<Identifier_t> alias);

	/** \brief Current module's name */
	std::string getModuleName();

	/**
	* \brief Looks for function with given name
	* \param name Function name to find
	* \note Requires that only one function exists under given name
	* \return Found function
	*/
	ManagedPtr<Function> findFunction(const std::string& name);

	/** \brief Returns all function in AST */
	std::list<ManagedFnPtr> getAllFunctions() const;

	/**
	* \brief Returns all specializations of a function with a given name
	* \param fnName function to find
	* \return list of found function specializations
	*/
	std::list<ManagedFnPtr> getFnSpecializations(const std::string& fnName) const;

	/**
	* \return First element in Functions/Scopes/Rules list depending on template parameter
	* \tparam Target either Function or CodeScope or MetaRuleAbstract
	*/
	template<class Target>
	ManagedPtr<Target> begin();

	/**
	* \brief Performs all necessary steps after AST is built
	*
	* Performs all finalization steps and moves AST into consistent state represented by xreate::AST
	* \sa xreate::AST
	* \return AST in consistent state
	*/
	xreate::AST* finalize();

	typedef std::multimap<std::string, unsigned int> FUNCTIONS_REGISTRY;

	//std::list<ExternData> __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 __dictFunctions;

	protected:
	std::map<std::string, TypeAnnotation> __registryTypes;

	public:
	/**
	* \brief Stores DFA scheme for later use by DFA Pass
	*
	* Treats expression as a DFA scheme and feeds to the DFA Pass later
	* \param data DFA Scheme
	* \sa xreate::DFAPass
	*/
	void addDFAData(Expression&& data);

	/** \brief Stores data for later use by xreate::ExternLayer */
	void addExternData(ExternData&& entry);

	/**
	* \brief Generalized function to store particular data for later use by particular pass
	* \param interface Particular Interface
	* \param data Particular data
	*/
	void addInterfaceData(const ASTInterface& interface, Expression&& data);


	/*\name Symbols Recognition /
	///@{
	public:
	//TODO revisit enums/variants, move to codescope
	/**
	* \brief Tries to find out whether expression is Variant constructor
	*/
	bool recognizeVariantConstructor(Expression& function);
	Atom<Number_t> recognizeVariantConstructor(Atom<Identifier_t> ident);
	/**
	* \brief Postpones unrecognized identifier for future second round of recognition
	* \param scope Code block identifier is encountered
	* \param id Identifier
	*/
	void postponeIdentifier(CodeScope* scope, const Expression& id);

	/** \brief Second round of identifiers recognition done right after AST is fully constructed */
	void recognizePostponedIdentifiers();

	void recognizeIntrinsic(Expression& fn) const;
	private:
	std::map<std::string, std::pair<TypeAnnotation, int>> __registryVariants;
	static std::map<std::string, IntrinsicFn> __registryIntrinsics;
	std::set<std::pair<CodeScope*, Expression>> __bucketUnrecognizedIdentifiers;

	static void initIntrinsics();

	public:

	///@}
	};

	template<>
	ManagedPtr<Function>
	AST::begin<Function>();

	template<>
	ManagedPtr<CodeScope>
	AST::begin<CodeScope>();

	template<>
	ManagedPtr<MetaRuleAbstract>
	AST::begin<MetaRuleAbstract>();

	} } // namespace details::incomplete

	/**
	* \brief AST in a consistent state
	*
	* AST has two mutually exclusive possible states:
	* - an inconsistent state while AST is under construction. Represented by xreate::details::inconsistent::AST
	* - a consistent state when AST is built and finalize() is invoked.
	*
	* This class represents a consistent state and should be used by clients unless client's code explicitly works with AST under construction.
	* Consistent AST enables access to additional functions(such as type management).
	* \sa xreate::details::inconsistent::AST
	*/
	class AST : public details::inconsistent::AST {
	public:

	AST() : details::inconsistent::AST() {}

	/**
	* \brief Computes fully expanded form of type by substituting all arguments and aliases
	* \param t Type to expand
	* \return Expdanded or normal form of type
	* \sa TypeAnnotation
	*/
	ExpandedType expandType(const TypeAnnotation &t) const;

	/**
	* Searches type by given name
	* \param name Typename to search
	* \return Expanded or normal form of desired type
	* \note if type name is not found returns new undefined type with this name
	*/
	ExpandedType findType(const std::string& name);

	/**
	* Invokes Type Inference Analysis to find out expanded(normal) form expressions's type
	* \sa typeinference.h
	* \param e
	* \param expectedT expected type
	* \return Type of expression

	*/
	ExpandedType getType(const Expression& e, const TypeAnnotation& expectedT = TypeAnnotation());
	};
	}
	#endif // AST_H
	diff --git a/cpp/src/compilation/containers.cpp b/cpp/src/compilation/containers.cpp
	index 6a50ca4..c6e7140 100644
	--- a/cpp/src/compilation/containers.cpp
	+++ b/cpp/src/compilation/containers.cpp
	@@ -1,262 +1,236 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: containers.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file compilation/containers.h
	* \brief Containers compilation support. See [Containers](/d/concepts/containers/) in the Xreate's documentation.
	*/

	#include "compilation/containers.h"
	#include "compilation/targetinterpretation.h"
	#include "aux/expressions.h"
	#include "compilation/containers/arrays.h"
	+#include "compilation/lambdas.h"
	+#include "analysis/predefinedanns.h"
	+#include "analysis/utils.h"

	using namespace std;
	-using namespace llvm;
	-using namespace xreate;
	-using namespace xreate::containers;
	-using namespace xreate::interpretation;
	-using namespace xreate::typehints;

	namespace xreate { namespace containers{

	+ImplementationType
	+IContainersIR::getImplementation(const Expression& aggrE, AST* ast){
	+ auto manPredefined = analysis::PredefinedAnns::instance();
	+ const Expression& hintE = analysis::findAnnByType(aggrE, ExpandedType(manPredefined.hintsContT), ast);
	+ assert(hintE.isValid());
	+
	+ return (ImplementationType ) hintE.getValueDouble();
	+}
	+
	IContainersIR *
	IContainersIR::create(const Expression &aggrE, const TypeAnnotation &expectedT, const compilation::Context &context){
	ExpandedType aggrT = context.pass->man->root->getType(aggrE, expectedT);
	Expression aggr2E;

	if (aggrE.__state == Expression::IDENT && !aggrE.tags.size()){
	Symbol aggrS = Attachments::get<IdentifierSymbol>(aggrE);
	aggr2E = CodeScope::getDefinition(aggrS);
	} else {
	aggr2E = aggrE;
	}

	switch(aggr2E.op){
	case Operator::LIST:{
	- typehints::Array aggrHint = typehints::getHint(
	- aggr2E, typehints::Array{aggr2E.operands.size()}
	+ typehints::ArrayHint aggrHint = typehints::find(
	+ aggr2E, typehints::ArrayHint{aggr2E.operands.size()}
	);

	- return new ArrayIR(context, aggrT, aggrHint);
	+ return new ArrayIR(aggrT, aggrHint, context);
	}

	default:
	- typehints::Array aggrHint = typehints::getHint(
	- aggr2E, typehints::Array{0}
	+ typehints::ArrayHint aggrHint = typehints::find(
	+ aggr2E, typehints::ArrayHint{0}
	);
	assert(aggrHint.size != 0);
	- return new ArrayIR(context, aggrT, aggrHint);
	+ return new ArrayIR(aggrT, aggrHint, context);
	}

	assert(false);
	return nullptr;
	}

	llvm::Value *
	RecordIR::init(llvm::StructType *tyAggr){
	return llvm::UndefValue::get(tyAggr);
	}

	+llvm::Value*
	+RecordIR::init(std::forward_list<llvm::Type*> fields){
	+ std::vector<llvm::Type*> fieldsVec(fields.begin(), fields.end());
	+ llvm::ArrayRef<llvm::Type *> fieldsArr(fieldsVec);
	+ llvm::StructType* resultTR = llvm::StructType::get(__context.pass->man->llvm->llvmContext, fieldsArr, false);
	+
	+ return init(resultTR);
	+}
	+
	llvm::Value *
	RecordIR::update(llvm::Value *aggrRaw, const ExpandedType &aggrT, const Expression &updE){
	- InterpretationScope *scopeI12n = __context.pass->targetInterpretation->transformContext(__context);
	+ interpretation::InterpretationScope *scopeI12n =
	+ __context.pass->targetInterpretation->transformContext(__context);
	TypesHelper helper(__context.pass->man->llvm);
	const auto &fields = helper.getRecordFields(aggrT);

	std::map<std::string, size_t> indexFields;
	for(size_t i = 0, size = fields.size(); i < size; ++i){
	indexFields.emplace(fields[i], i);
	}

	for(const auto &entry: reprListAsDict(updE)){
	unsigned keyId;
	std::string keyHint;
	const Expression keyE = scopeI12n->process(entry.first);

	switch(keyE.__state){
	case Expression::STRING:
	keyId = indexFields.at(keyE.getValueString());
	keyHint = keyE.getValueString();
	break;

	case Expression::NUMBER:
	keyId = keyE.getValueDouble();
	keyHint = aggrT->fields.at(keyId);
	break;
	default:
	assert(false);
	break;
	}

	const TypeAnnotation &valueT = aggrT->__operands.at(keyId);

	llvm::Value *valueRaw = __context.scope->process(entry.second, keyHint, valueT);
	aggrRaw = __context.pass->man->llvm->irBuilder.CreateInsertValue(
	aggrRaw,
	valueRaw,
	keyId);
	}

	return aggrRaw;
	}

	-//IFwdIteratorIR*
	-//IFwdIteratorIR::create(xreate::compilation::Context context, const xreate::Symbol& var){
	-// const Implementation& data = Query::queryImplementation(var);
	-//
	-// switch(data.impl){
	-// case ON_THE_FLY:
	-// return new FwdIteratorIR<ON_THE_FLY>(context, var, data.extract<ON_THE_FLY>());
	-//
	-// case SOLID:
	-// return new FwdIteratorIR<SOLID>(context, var, data.extract<SOLID>());
	-//
	-// default: break;
	-//}
	-//
	-// assert(false && "Unknown declaration");
	-// return nullptr;
	-//}
	-//
	-//llvm::Value*
	-//FwdIteratorIR<ON_THE_FLY>::begin() {
	-// switch(sourceDecl.op) {
	-// case xreate::Operator::LIST:
	-// {
	-// sourceRawType = llvm::Type::getInt32Ty(llvm->llvmContext);
	-// return llvm::ConstantInt::get(Type::getInt32Ty(llvm->llvmContext), 0);
	-// };
	-//
	-// case xreate::Operator::LIST_RANGE:{
	-// assert(sourceDecl.operands.size()==2);
	-//
	-// llvm::Value* result = sourceUnit->process(sourceDecl.operands.at(0));
	-// sourceRawType = result->getType();
	-//
	-// return result;
	-// };
	-//
	-// default: break;
	-// }
	-//
	-// if (linkedlist){
	-// llvm::Value* result = sourceUnit->process(sourceDecl);
	-// sourceRawType = result->getType();
	-// return result;
	-// }
	-//
	-// assert(false);
	-//}
	-//
	-//llvm::Value*
	-//FwdIteratorIR<ON_THE_FLY>::end(){
	-// switch(sourceDecl.op) {
	-// case xreate::Operator::LIST: {
	-// size_t idLast = sourceDecl.operands.size() - 1;
	-// return ConstantInt::get(sourceRawType, idLast);
	-// }
	-//
	-// case xreate::Operator::LIST_RANGE: {
	-// assert(sourceDecl.operands.size() == 2);
	-// llvm::Value* valueEndOfRange = sourceUnit->process(sourceDecl.operands.at(1));
	-// llvm::Value* valueConstOne = llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm->llvmContext), 1);
	-//
	-// return llvm->irBuilder.CreateAdd(valueEndOfRange, valueConstOne);
	-// };
	-//
	-// default: break;
	-// }
	-//
	-// //return null pointer
	-// if (linkedlist){
	-// return ConstantPointerNull::getNullValue(sourceRawType);
	-// }
	-//
	-// assert(false && "Unknown declaration");
	-// return nullptr;
	-//}
	-//
	-//llvm::Value*
	-//FwdIteratorIR<ON_THE_FLY>::get(Value* index, const std::string& hintRetVar){
	-// const Expression& currentDecl = CodeScope::getDefinition(current);
	-//
	-// switch (currentDecl.op) {
	-// case xreate::Operator::LIST: {
	-// //TODO re check is it right scope(source) to compile currentDecl. Provide unittests.
	-// llvm::Value* currentValue = sourceUnit->processSymbol(current);
	-// return xreate::compilation::ControlIR(context).compileArrayIndex(currentValue, std::vector<Value *>{index});
	-// };
	-//
	-// case xreate::Operator::LIST_RANGE: {
	-// return index;
	-// };
	-//
	-// case xreate::Operator::MAP: {
	-// assert(currentDecl.getOperands().size()==1);
	-// assert(currentDecl.bindings.size());
	-// assert(currentDecl.blocks.size());
	-//
	-// CodeScope* scopeLoop = currentDecl.blocks.front();
	-// std::string varEl = currentDecl.bindings[0];
	-//
	-// const Symbol& symbIn = Attachments::get<IdentifierSymbol>(currentDecl.getOperands()[0]);
	-// auto it = std::unique_ptr<IFwdIteratorIR>(IFwdIteratorIR::create(context, symbIn));
	-//
	-// Value* elIn = it->get(index, varEl);
	-// compilation::IBruteScope* unitLoop = function->getScopeUnit(scopeLoop);
	-// unitLoop->bindArg(elIn, std::move(varEl));
	-// return unitLoop->compile();
	-// }
	-//
	-// case xreate::Operator::INVALID: {
	-// //TODO review iterator determination strategy for case of Expression::BINDING
	-// assert(currentDecl.__state==Expression::IDENT);
	-//
	-// const Symbol& symbIn = Attachments::get<IdentifierSymbol>(currentDecl);
	-// auto it = std::unique_ptr<IFwdIteratorIR>(IFwdIteratorIR::create(context, symbIn));
	-// return it->get(index);
	-// };
	-//
	-// default: break;
	-// }
	-//
	-// if (linkedlist){
	-// return index;
	-// }
	-//
	-// assert(false && "Unknown declaration");
	-// return nullptr;
	-//}
	-//
	-//llvm::Value*
	-//FwdIteratorIR<ON_THE_FLY>::advance(Value* index, const std::string& hintRetVar){
	-// switch(sourceDecl.op)
	-// {
	-// case xreate::Operator::LIST:
	-// case xreate::Operator::LIST_RANGE:
	-// return llvm->irBuilder.CreateAdd(index, llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm->llvmContext), 1), hintRetVar);
	-//
	-// default: break;
	-// }
	-//
	-// if (linkedlist){
	-// ExpandedType tySource = llvm->ast->getType(CodeScope::getDefinition(source));
	-// assert(tySource->__operator == TypeOperator::ARRAY && "Linked list implementation has to have ARRAY type");
	-// assert(tySource->__operands.size());
	-//
	-// return xreate::compilation::ControlIR(context).compileStructIndex(index, ExpandedType(TypeAnnotation(tySource->__operands.at(0))), {linkedlist.fieldPointer});
	-// }
	-//
	-// assert(false && "Unknown declaration");
	-// return nullptr;
	-//}
	-
	-//const ImplementationRec<ON_THE_FLY>& implementation
	+llvm::Value*
	+FlyIR::create(llvm::Value* sourceRaw, CodeScope* body, const std::string& hintAlias){
	+ RecordIR recordIR(__context);
	+ compilation::LambdaIR lambdaIR(__context.pass);
	+ llvm::Function* fnTransform = lambdaIR.compile(body, hintAlias);
	+
	+ llvm::Value* resultRaw = recordIR.init({
	+ sourceRaw->getType(),
	+ fnTransform->getFunctionType()->getPointerTo()
	+ });
	+
	+ resultRaw = __context.pass->man->llvm->irBuilder.CreateInsertValue(
	+ resultRaw, sourceRaw, 0);
	+ resultRaw = __context.pass->man->llvm->irBuilder.CreateInsertValue(
	+ resultRaw, fnTransform, 1);
	+
	+ return resultRaw;
	+}
	+
	+llvm::Value*
	+FlyIR::getTransformFn(llvm::Value* aggrRaw){
	+ LLVMLayer* llvm = __context.pass->man->llvm;
	+ llvm::Value* fnRaw = llvm->irBuilder.CreateExtractValue(aggrRaw, llvm::ArrayRef<unsigned>{1});
	+
	+ return fnRaw;
	+}
	+
	+llvm::Value* FlyIR::getSourceAggr(llvm::Value* aggrRaw){
	+ LLVMLayer* llvm = __context.pass->man->llvm;
	+ return llvm->irBuilder.CreateExtractValue(aggrRaw, llvm::ArrayRef<unsigned>{0});
	+}
	+
	+llvm::Value*
	+FlyIR::operatorMap(const Expression& expr, const std::string& hintAlias){
	+ const Expression& sourceE = expr.getOperands().at(0);
	+ llvm::Value* sourceRaw = __context.scope->process(sourceE);
	+ CodeScope* loopS = expr.blocks.front();
	+
	+ return create(sourceRaw, loopS, hintAlias);
	+}
	+
	+FlyIR::FlyIR(typehints::FlyHint hint, compilation::Context context)
	+ : __hint(hint), __context(context){}
	+
	+IFwdIteratorIR*
	+IFwdIteratorIR::createByHint(const Expression& hintE, const ExpandedType& aggrT, const compilation::Context& context){
	+ ImplementationType hintType = (ImplementationType) hintE.getValueDouble();
	+
	+ switch(hintType){
	+ case SOLID:{
	+ ArrayIR compiler(aggrT, typehints::parse<typehints::ArrayHint>(hintE), context);
	+ return new FwdIteratorIR<SOLID>(compiler);
	+ }
	+
	+ case ON_THE_FLY:{
	+ return new FwdIteratorIR<ON_THE_FLY>(typehints::parse<typehints::FlyHint>(hintE), aggrT, context);
	+ }
	+
	+ default: break;
	+ }
	+
	+ assert(false);
	+ return nullptr;
	+}
	+
	+IFwdIteratorIR*
	+IFwdIteratorIR::create(const Expression& aggrE, const ExpandedType& aggrT, const compilation::Context& context){
	+ auto manPredefined = analysis::PredefinedAnns::instance();
	+ const Expression& hintE = analysis::findAnnByType(
	+ aggrE,
	+ ExpandedType(manPredefined.hintsContT),
	+ context.pass->man->root
	+ );
	+ assert(hintE.isValid());
	+
	+ return createByHint(hintE, aggrT, context);
	+}
	+
	+llvm::Value*
	+FwdIteratorIR<ON_THE_FLY>::begin() {
	+ std::unique_ptr<IFwdIteratorIR> itSrcIR(IFwdIteratorIR::createByHint(__hint.hintSrc, __aggrT, __context));
	+ return itSrcIR->begin();
	+}
	+
	+llvm::Value*
	+FwdIteratorIR<ON_THE_FLY>::end() {
	+ std::unique_ptr<IFwdIteratorIR> itSrcIR(IFwdIteratorIR::createByHint(__hint.hintSrc, __aggrT, __context));
	+ return itSrcIR->end();
	+}
	+
	+llvm::Value*
	+FwdIteratorIR<ON_THE_FLY>::advance(llvm::Value* idxRaw, const std::string& hintAlias){
	+ std::unique_ptr<IFwdIteratorIR> itSrcIR(IFwdIteratorIR::createByHint(__hint.hintSrc, __aggrT, __context));
	+ return itSrcIR->advance(idxRaw, hintAlias);
	+}
	+
	+llvm::Value*
	+FwdIteratorIR<ON_THE_FLY>::get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintAlias){
	+ std::unique_ptr<IFwdIteratorIR> srcIterIR(IFwdIteratorIR::createByHint(__hint.hintSrc, __aggrT, __context));
	+ FlyIR compilerFly(__hint, __context);
	+ llvm::Value* aggrSrcRaw = compilerFly.getSourceAggr(aggrRaw);
	+ llvm::Value* valueSrcRaw = srcIterIR->get(aggrSrcRaw, idxRaw);
	+ FlyIR flyIR(__hint, __context);
	+ llvm::Value* fnTnsfRaw = flyIR.getTransformFn(aggrRaw);
	+ llvm::Type* fnTnsfTRawRaw = llvm::cast<llvm::PointerType>(fnTnsfRaw->getType())->getElementType();
	+ llvm::FunctionType* fnTnsfTRaw = llvm::cast<llvm::FunctionType>(fnTnsfTRawRaw);
	+ compilation::BruteFnInvocation fnTnsfInvoc(fnTnsfRaw, fnTnsfTRaw, __context.pass->man->llvm);
	+ return fnTnsfInvoc({valueSrcRaw}, hintAlias);
	+}

	}} //end of xreate::containers
	diff --git a/cpp/src/compilation/containers.h b/cpp/src/compilation/containers.h
	index 4e830e8..8c953f3 100644
	--- a/cpp/src/compilation/containers.h
	+++ b/cpp/src/compilation/containers.h
	@@ -1,103 +1,108 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: containers.h
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#ifndef CODEINSTRUCTIONS_H
	#define CODEINSTRUCTIONS_H

	#include "ast.h"

	#include "llvmlayer.h"
	#include "pass/compilepass.h"
	#include "compilation/control.h"
	#include "query/containers.h"
	#include "analysis/typehints.h"

	namespace xreate { namespace containers {

	class IFwdIteratorIR;

	class IContainersIR{
	public:
	static IContainersIR *create(
	const Expression &aggrE,
	const TypeAnnotation &expectedT,
	const compilation::Context &context);

	+ static ImplementationType getImplementation(const Expression& aggrE, AST* ast);
	+
	virtual llvm::Value *init(const std::string &hintAlias = "") = 0;
	virtual llvm::Value update(llvm::Value aggrRaw, const Expression &updE, const std::string &hintAlias) = 0;
	virtual IFwdIteratorIR* getFwdIterator() = 0;
	virtual ~IContainersIR(){}
	};

	class RecordIR{
	public:
	RecordIR(const compilation::Context& context): __context(context){}
	llvm::Value* init(llvm::StructType* tyAggr);
	+ llvm::Value* init(std::forward_list<llvm::Type*> fields);
	llvm::Value* update(llvm::Value* aggrRaw, const ExpandedType& aggrT, const Expression& updE);

	private:
	compilation::Context __context;
	};

	+class FlyIR{
	+public:
	+ FlyIR(typehints::FlyHint hint, compilation::Context context);
	+
	+ llvm::Value* create(llvm::Value* sourceRaw, CodeScope* body, const std::string& hintAlias);
	+ llvm::Value* getSourceAggr(llvm::Value* aggrRaw);
	+ llvm::Value* getTransformFn(llvm::Value* aggrRaw);
	+ llvm::Value* operatorMap(const Expression& expr, const std::string& hintAlias);
	+
	+private:
	+ typehints::FlyHint __hint;
	+ compilation::Context __context;
	+};
	+
	/**
	* \brief A factory to create a concrete iterator based on the solution provided by xreate::containers::Query
	* \sa xreate::containers::Query
	*/
	class IFwdIteratorIR{
	public :
	virtual ~IFwdIteratorIR(){};

	virtual llvm::Value* begin() = 0;
	virtual llvm::Value* end() = 0;
	- virtual llvm::Value* get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintRetVar="") = 0;
	+ virtual llvm::Value* get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintAlias="") = 0;
	virtual llvm::Value* advance(llvm::Value* idxRaw, const std::string& hintAlias="") = 0;
	+
	+ static IFwdIteratorIR* create(const Expression& aggrE, const ExpandedType& aggrT, const compilation::Context& context);
	+ static IFwdIteratorIR* createByHint(const Expression& hintE, const ExpandedType& aggrT, const compilation::Context& context);
	};

	template<ImplementationType I>
	class FwdIteratorIR;

	+
	/** \brief The lazy container implementation.
	*
	* Represents computation on the fly.
	* \sa xreate::containers::IFwdIteratorIR, \sa xreate::containers::Query
	*/
	-//template<>
	-//class FwdIteratorIR<ON_THE_FLY> : public IFwdIteratorIR {
	-//private:
	-// LLVMLayer* llvm;
	-// const xreate::Symbol current;
	-// const Symbol source;
	-// const ImplementationLinkedList linkedlist;
	-// const CodeScope* const sourceScope;
	-// //TODO initialize and mark as const (three fields)
	-// compilation::IBruteScope* sourceUnit;
	-// compilation::IBruteFunction* function; //TODO is used somewhere?
	-// const Expression& sourceDecl;
	-// compilation::Context context;
	-// llvm::Type* sourceRawType =nullptr;
	-//
	-//public:
	-// FwdIteratorIR(const compilation::Context& ctx, const xreate::Symbol& s, const ImplementationRec<ON_THE_FLY>& implementation)
	-// : llvm(ctx.pass->man->llvm),
	-// current(s),
	-// source(implementation.source),
	-// linkedlist(source),
	-// sourceScope(source.scope),
	-// sourceUnit(ctx.function->getScopeUnit(source.scope)),
	-// sourceDecl(CodeScope::getDefinition(source)),
	-// context(ctx)
	-// {}
	-//
	-// llvm::Value* begin() override;
	-// llvm::Value* end() override;
	-// llvm::Value* get(llvm::Value* index,const std::string& hintRetVar="") override;
	-// llvm::Value* advance(llvm::Value* idxRaw, const std::string& hintAlias="") override;
	-//};
	+template<>
	+class FwdIteratorIR<ON_THE_FLY> : public IFwdIteratorIR {
	+public:
	+ FwdIteratorIR<ON_THE_FLY>(typehints::FlyHint hint, const ExpandedType &aggrT, compilation::Context context)
	+ : __aggrT(aggrT), __hint(hint), __context(context){}
	+
	+ virtual llvm::Value* begin() override;
	+ virtual llvm::Value* end() override;
	+ virtual llvm::Value* get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintAlias="") override;
	+ virtual llvm::Value* advance(llvm::Value* idxRaw, const std::string& hintAlias="") override;
	+
	+private:
	+ ExpandedType __aggrT;
	+ typehints::FlyHint __hint;
	+ compilation::Context __context;
	+};
	}}

	#endif //CODEINSTRUCTIONS_H
	diff --git a/cpp/src/compilation/containers/arrays.cpp b/cpp/src/compilation/containers/arrays.cpp
	index ea287bd..d57ff02 100644
	--- a/cpp/src/compilation/containers/arrays.cpp
	+++ b/cpp/src/compilation/containers/arrays.cpp
	@@ -1,106 +1,169 @@
	-//
	-// Created by pgess on 27/03/2020.
	-//
	+/* This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * File: arrays.cpp
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ *
	+ * Created in March 2020.
	+ */

	#include "compilation/containers/arrays.h"
	#include "aux/expressions.h"

	using namespace std;
	using namespace llvm;

	namespace xreate { namespace containers{

	llvm::ArrayType*
	ArrayIR::getRawT(){
	assert(__aggrT->__operator == TypeOperator::ARRAY);
	assert(__aggrT->__operands.size() == 1);

	LLVMLayer* llvm = __context.pass->man->llvm;
	llvm::Type* elRawT = llvm->toLLVMType(ExpandedType(__aggrT->__operands.at(0)));

	return llvm::ArrayType::get(elRawT, __hints.size);
	}

	llvm::Value*
	ArrayIR::init(const string& hintAlias){
	LLVMLayer* llvm = __context.pass->man->llvm;
	TypesHelper helper(llvm);
	llvm::ArrayType* aggrRawT = getRawT();

	//llvm::Value* aggrLengthRaw = ConstantInt::get(helper.getPreferredIntTy(), aggrInfo.size);
	llvm::Value* aggrRaw = llvm->irBuilder.CreateAlloca(aggrRawT, nullptr, hintAlias);

	return aggrRaw;
	}

	llvm::Value*
	ArrayIR::update(llvm::Value* aggrRaw, const Expression& updE, const std::string& hintAlias) {
	LLVMLayer* llvm = __context.pass->man->llvm;
	TypesHelper helper(llvm);
	llvm::IntegerType* intT = helper.getPreferredIntTy();
	llvm::Value* idxZeroRaw = ConstantInt::get(intT, 0);
	llvm::ArrayType* aggrRawT = getRawT();
	const TypeAnnotation& elT = __aggrT->__operands.at(0);
	//llvm::Type* elTRaw = llvm->toLLVMType(ExpandedType(aggrT->__operands.at(0)));

	for (const auto& entry: reprListAsDict(updE)){
	llvm::Value* keyRaw = __context.scope->process(entry.first);
	llvm::Value* elRaw = __context.scope->process(entry.second, "", elT);

	llvm::Value* elLoc = llvm->irBuilder.CreateGEP(
	aggrRawT, aggrRaw, ArrayRef<llvm::Value>(std::vector<Value>{idxZeroRaw, keyRaw}));
	llvm->irBuilder.CreateStore(elRaw, elLoc) ;
	}

	return aggrRaw;
	}

	llvm::Value*
	ArrayIR::get(llvm::Value* aggrRaw, std::vector<llvm::Value *> idxL, const std::string& hintAlias) {
	LLVMLayer* llvm = __context.pass->man->llvm;
	TypesHelper helper(llvm);
	llvm::IntegerType* intT = helper.getPreferredIntTy();
	llvm::Value* zeroRaw = ConstantInt::get(intT, 0);

	idxL.insert(idxL.begin(), zeroRaw);
	llvm::Value pEl = llvm->irBuilder.CreateGEP(aggrRaw, llvm::ArrayRef<llvm::Value >(idxL));
	return llvm->irBuilder.CreateLoad(pEl, hintAlias);
	}

	+llvm::Value*
	+ArrayIR::operatorMap(const Expression& expr, const std::string& hintAlias) {
	+ assert(false); return nullptr;
	+ //EXPAND_CONTEXT UNUSED(scope);
	+
	+// //initializationcompileListAsSolidArray
	+// Symbol symbolIn = Attachments::get<IdentifierSymbol>(expr.getOperands()[0]);
	+//
	+// ImplementationRec<SOLID> implIn = containers::Query::queryImplementation(symbolIn).extract<SOLID>(); // impl of input list
	+// size_t size = implIn.size;
	+// CodeScope* scopeLoop = expr.blocks.front();
	+// std::string varEl = scopeLoop->__bindings[0];
	+//
	+// IFwdIteratorIR* it = IFwdIteratorIR::create(context, symbolIn);
	+// llvm::Value *rangeFrom = it->begin();
	+// llvm::Value *rangeTo = it->end();
	+//
	+// //definitions
	+// ArrayType* tyNumArray = nullptr; //(ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::Int, size))));
	+// llvm::IRBuilder<> &builder = llvm->irBuilder;
	+//
	+// llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm->llvmContext, "loop", function->raw);
	+// llvm::BasicBlock *blockBeforeLoop = builder.GetInsertBlock();
	+// llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm->llvmContext, "postloop", function->raw);
	+// Value* dataOut = llvm->irBuilder.CreateAlloca(tyNumArray, ConstantInt::get(tyNum, size), NAME("map"));
	+//
	+// // * initial check
	+// Value* condBefore = builder.CreateICmpSLE(rangeFrom, rangeTo);
	+// builder.CreateCondBr(condBefore, blockLoop, blockAfterLoop);
	+//
	+// // create PHI:
	+// builder.SetInsertPoint(blockLoop);
	+// llvm::PHINode *stateLoop = builder.CreatePHI(tyNum, 2, "mapIt");
	+// stateLoop->addIncoming(rangeFrom, blockBeforeLoop);
	+//
	+// // loop body:
	+// Value* elIn = it->get(stateLoop, varEl);
	+// compilation::IBruteScope* scopeLoopUnit = function->getScopeUnit(scopeLoop);
	+// scopeLoopUnit->bindArg(elIn, move(varEl));
	+// Value* elOut = scopeLoopUnit->compile();
	+// Value pElOut = builder.CreateGEP(dataOut, ArrayRef<Value >(std::vector<Value*>{ConstantInt::get(tyNum, 0), stateLoop}));
	+// builder.CreateStore(elOut, pElOut);
	+//
	+// //next iteration preparing
	+// Value *stateLoopNext = builder.CreateAdd(stateLoop, llvm::ConstantInt::get(tyNum, 1));
	+// stateLoop->addIncoming(stateLoopNext, builder.GetInsertBlock());
	+//
	+// //next iteration checks:
	+// Value* condAfter = builder.CreateICmpSLE(stateLoopNext, rangeTo);
	+// builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);
	+//
	+// //finalization:
	+// builder.SetInsertPoint(blockAfterLoop);
	+//
	+// return dataOut;
	+}
	+
	IFwdIteratorIR* ArrayIR::getFwdIterator(){
	- return new FwdIteratorIR<SOLID>(this);
	+ return new FwdIteratorIR<SOLID>(*this);
	}

	llvm::Value *
	FwdIteratorIR<SOLID>::begin(){
	- TypesHelper helper(__arraysIR->__context.pass->man->llvm);
	+ TypesHelper helper(__compiler.__context.pass->man->llvm);
	llvm::IntegerType* intT = helper.getPreferredIntTy();

	return llvm::ConstantInt::get(intT, 0);
	}

	llvm::Value *
	FwdIteratorIR<SOLID>::end(){
	- TypesHelper helper(__arraysIR->__context.pass->man->llvm);
	+ TypesHelper helper(__compiler.__context.pass->man->llvm);
	llvm::IntegerType* intT = helper.getPreferredIntTy();
	- size_t size = __arraysIR->__hints.size;
	+ size_t size = __compiler.__hints.size;

	return llvm::ConstantInt::get(intT, size);
	}

	llvm::Value *
	FwdIteratorIR<SOLID>::get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintAlias){
	- return __arraysIR->get(aggrRaw, {idxRaw}, hintAlias);
	+ return __compiler.get(aggrRaw, {idxRaw}, hintAlias);
	}

	llvm::Value *
	FwdIteratorIR<SOLID>::advance(llvm::Value *idxRaw, const std::string &hintAlias){
	- LLVMLayer* llvm = __arraysIR->__context.pass->man->llvm;
	+ LLVMLayer* llvm = __compiler.__context.pass->man->llvm;
	TypesHelper helper(llvm);
	llvm::IntegerType* intT = helper.getPreferredIntTy();
	llvm::Value* cnstOneRaw = llvm::ConstantInt::get(intT, 1);

	return llvm->irBuilder.CreateAdd(idxRaw, cnstOneRaw, hintAlias);
	}

	}} //xreate::containers
	\ No newline at end of file
	diff --git a/cpp/src/compilation/containers/arrays.h b/cpp/src/compilation/containers/arrays.h
	index 3401940..8951d9d 100644
	--- a/cpp/src/compilation/containers/arrays.h
	+++ b/cpp/src/compilation/containers/arrays.h
	@@ -1,53 +1,63 @@
	-//
	-// Created by pgess on 27/03/2020.
	-//
	+/* This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * File: arrays.h
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ *
	+ * Created in March 2020.
	+ */

	-#ifndef XREATE_ARRAYSIR_H
	+ifndef XREATE_ARRAYSIR_H
	#define XREATE_ARRAYSIR_H

	#include "compilation/containers.h"

	namespace xreate { namespace containers{

	-class ArrayIR;
	+class IFwdIteratorIR;

	/** \brief The contiguous container implementation.
	*
	* Represents contiguous in memory(array) implementation.
	* \sa xreate::containers::IFwdIteratorIR, \sa xreate::containers::Query
	*/
	-template<>
	-class FwdIteratorIR<SOLID>: public IFwdIteratorIR {
	- ArrayIR* __arraysIR;
	-
	-public:
	- FwdIteratorIR(ArrayIR* arraysIR): __arraysIR(arraysIR) {};
	-
	- virtual llvm::Value* begin() override;
	- virtual llvm::Value* end() override;
	- virtual llvm::Value* get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintRetVar="") override;
	- virtual llvm::Value* advance(llvm::Value* idxRaw, const std::string& hintAlias="") override;
	-};
	-
	class ArrayIR : public IContainersIR{
	friend class FwdIteratorIR<SOLID>;

	public:
	- ArrayIR(const compilation::Context &context, const ExpandedType &aggrT, const typehints::Array &hints)
	+ ArrayIR(const ExpandedType &aggrT, const typehints::ArrayHint &hints, const compilation::Context &context)
	: __context(context), __aggrT(aggrT), __hints(hints){}

	virtual llvm::Value *init(const std::string &hintAlias = "") override;
	virtual llvm::Value update(llvm::Value aggrRaw, const Expression &updE, const std::string &hintAlias) override;
	virtual IFwdIteratorIR* getFwdIterator() override;
	llvm::Value get(llvm::Value aggrRaw, std::vector<llvm::Value *> idxL, const std::string &hintAlias);
	llvm::ArrayType *getRawT();

	+ /** \brief `loop map` statement compilation*/
	+ llvm::Value* operatorMap(const Expression& expr, const std::string& hintAlias);
	+
	private:
	compilation::Context __context;
	ExpandedType __aggrT;
	- typehints::Array __hints;
	+ typehints::ArrayHint __hints;
	+};
	+
	+template<>
	+class FwdIteratorIR<SOLID>: public IFwdIteratorIR {
	+public:
	+ FwdIteratorIR(const ArrayIR& arraysIR): __compiler(arraysIR) {};
	+
	+ virtual llvm::Value* begin() override;
	+ virtual llvm::Value* end() override;
	+ virtual llvm::Value* get(llvm::Value* aggrRaw, llvm::Value *idxRaw, const std::string &hintAlias="") override;
	+ virtual llvm::Value* advance(llvm::Value* idxRaw, const std::string& hintAlias="") override;
	+
	+private:
	+ ArrayIR __compiler;
	};

	}} // xreate::containers

	#endif //XREATE_ARRAYSIR_H
	diff --git a/cpp/src/compilation/control.cpp b/cpp/src/compilation/control.cpp
	index c300b7e..3c55f04 100644
	--- a/cpp/src/compilation/control.cpp
	+++ b/cpp/src/compilation/control.cpp
	@@ -1,441 +1,393 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: InstructionsAdvanced.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 26, 2016, 6:00 PM
	*/

	#include "analysis/typeinference.h"
	#include "compilation/control.h"
	#include "compilation/containers.h"
	#include "compilation/transformersaturation.h"

	#include "query/containers.h"
	#include "llvmlayer.h"
	#include "ast.h"

	using namespace std;
	using namespace llvm;
	using namespace xreate;
	using namespace xreate::containers;
	using namespace xreate::compilation;

	#define NAME(x) (hintRetVar.empty()? x : hintRetVar)
	#define UNUSED(x) (void)(x)
	#define EXPAND_CONTEXT \
	LLVMLayer* llvm = context.pass->man->llvm; \
	compilation::IBruteScope* scope = context.scope; \
	compilation::IBruteFunction* function = context.function;

	ControlIR::ControlIR(compilation::Context ctx)
	: context(ctx), tyNum(static_cast<llvm::IntegerType*> (ctx.pass->man->llvm->toLLVMType(ExpandedType(TypeAnnotation(TypePrimitive::Int))))) {
	}

	-llvm::Value*
	-ControlIR::compileMapSolidOutput(const Expression &expr, const std::string hintRetVar) {
	- assert(false); return nullptr;
	- EXPAND_CONTEXT UNUSED(scope);
	-
	-// //initializationcompileListAsSolidArray
	-// Symbol symbolIn = Attachments::get<IdentifierSymbol>(expr.getOperands()[0]);
	-//
	-// ImplementationRec<SOLID> implIn = containers::Query::queryImplementation(symbolIn).extract<SOLID>(); // impl of input list
	-// size_t size = implIn.size;
	-// CodeScope* scopeLoop = expr.blocks.front();
	-// std::string varEl = scopeLoop->__bindings[0];
	-//
	-// IFwdIteratorIR* it = IFwdIteratorIR::create(context, symbolIn);
	-// llvm::Value *rangeFrom = it->begin();
	-// llvm::Value *rangeTo = it->end();
	-//
	-// //definitions
	-// ArrayType* tyNumArray = nullptr; //(ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::Int, size))));
	-// llvm::IRBuilder<> &builder = llvm->irBuilder;
	-//
	-// llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm->llvmContext, "loop", function->raw);
	-// llvm::BasicBlock *blockBeforeLoop = builder.GetInsertBlock();
	-// llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm->llvmContext, "postloop", function->raw);
	-// Value* dataOut = llvm->irBuilder.CreateAlloca(tyNumArray, ConstantInt::get(tyNum, size), NAME("map"));
	-//
	-// // * initial check
	-// Value* condBefore = builder.CreateICmpSLE(rangeFrom, rangeTo);
	-// builder.CreateCondBr(condBefore, blockLoop, blockAfterLoop);
	-//
	-// // create PHI:
	-// builder.SetInsertPoint(blockLoop);
	-// llvm::PHINode *stateLoop = builder.CreatePHI(tyNum, 2, "mapIt");
	-// stateLoop->addIncoming(rangeFrom, blockBeforeLoop);
	-//
	-// // loop body:
	-// Value* elIn = it->get(stateLoop, varEl);
	-// compilation::IBruteScope* scopeLoopUnit = function->getScopeUnit(scopeLoop);
	-// scopeLoopUnit->bindArg(elIn, move(varEl));
	-// Value* elOut = scopeLoopUnit->compile();
	-// Value pElOut = builder.CreateGEP(dataOut, ArrayRef<Value >(std::vector<Value*>{ConstantInt::get(tyNum, 0), stateLoop}));
	-// builder.CreateStore(elOut, pElOut);
	-//
	-// //next iteration preparing
	-// Value *stateLoopNext = builder.CreateAdd(stateLoop, llvm::ConstantInt::get(tyNum, 1));
	-// stateLoop->addIncoming(stateLoopNext, builder.GetInsertBlock());
	-//
	-// //next iteration checks:
	-// Value* condAfter = builder.CreateICmpSLE(stateLoopNext, rangeTo);
	-// builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);
	-//
	-// //finalization:
	-// builder.SetInsertPoint(blockAfterLoop);
	-//
	-// return dataOut;
	-}
	-
	Value*
	ControlIR::compileStructIndex(llvm::Value* aggregate, ExpandedType aggrT, const list<string>& indices) {
	EXPAND_CONTEXT UNUSED(scope); UNUSED(function);
	TypesHelper types(llvm);
	llvm::Value* result = aggregate;
	assert(indices.size());

	for (const string& indexField: indices){
	const std::vector<std::string>& tyfields = types.getRecordFields(aggrT);
	unsigned idx = -1; bool flagFound = false;
	for (unsigned i = 0, size = tyfields.size(); i < size; ++i) {
	if (tyfields.at(i) == indexField) {
	idx = i; flagFound = true; break;
	}
	}

	if (flagFound){
	result = llvm->irBuilder.CreateExtractValue(result, llvm::ArrayRef<unsigned>{idx});
	aggrT = typeinference::getSubtype(aggrT, indexField);
	} else {
	assert(false && "not found required struct field");
	}
	}

	return result;

	//dereference pointer
	//if (types.isPointerT(t)) {
	// llvm::Value* addr = llvm->irBuilder.CreateConstGEP2_32(nullptr, aggregate, 0, i);
	// return llvm->irBuilder.CreateLoad(addr);
	//}
	}

	llvm::Value*
	ControlIR::compileFold(const Expression& loopE, const std::string& hintAlias) {
	EXPAND_CONTEXT
	assert(loopE.op == Operator::FOLD);
	AST* ast = context.pass->man->root;

	+
	//initialization:
	const Expression aggrE = loopE.getOperands().at(0);
	+ const ExpandedType& aggrT = ast->getType(aggrE);
	llvm::Value* aggrRaw = context.scope->process(aggrE);
	- std::unique_ptr<IContainersIR> containerIR(IContainersIR::create(aggrE, TypeAnnotation(), context));
	- IFwdIteratorIR* aggrItIR = containerIR->getFwdIterator();
	+
	+ IFwdIteratorIR* aggrItIR = IFwdIteratorIR::create(aggrE, aggrT, context);
	llvm::Value* idxBeginRaw = aggrItIR->begin();
	llvm::Value* idxEndRaw = aggrItIR->end();
	ExpandedType loopT = ast->getType(loopE);
	std::string elAlias = loopE.bindings[0];
	std::string accumAlias = loopE.bindings[1];
	const Expression& accumE = loopE.getOperands().at(1);
	ExpandedType accumT = ast->getType(accumE, loopT.get());
	llvm::Type* accumRawT = llvm->toLLVMType(accumT);
	llvm::Value* accumInitRaw = scope->process(accumE, accumAlias, accumT.get());

	- llvm::BasicBlock *blockBeforeLoop = llvm->irBuilder.GetInsertBlock();
	- std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));
	-
	- llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm->llvmContext, "fold", function->raw);
	- llvm::BasicBlock *blockLoopBody = llvm::BasicBlock::Create(llvm->llvmContext, "fold_body", function->raw);
	- llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm->llvmContext, "fold_after", function->raw);
	- llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm->llvmContext, "fold_next", function->raw);
	+ llvm::BasicBlock *blockProlog = llvm::BasicBlock::Create(llvm->llvmContext, "fold_prlg", function->raw);
	+ llvm::BasicBlock *blockHeader = llvm::BasicBlock::Create(llvm->llvmContext, "fold_hdr", function->raw);
	+ llvm::BasicBlock *blockBody = llvm::BasicBlock::Create(llvm->llvmContext, "fold", function->raw);
	+ llvm::BasicBlock *blockFooter = llvm::BasicBlock::Create(llvm->llvmContext, "fold_ftr", function->raw);
	+ llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm->llvmContext, "fold_eplg", function->raw);

	- llvm->irBuilder.CreateBr(blockLoop);
	+ std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockProlog, context.pass->managerTransformations));

	+ //Header:
	// * create phi
	- llvm->irBuilder.SetInsertPoint(blockLoop);
	+ llvm->irBuilder.SetInsertPoint(blockHeader);
	llvm::PHINode *accum = llvm->irBuilder.CreatePHI(accumRawT, 2, accumAlias);
	- accum->addIncoming(accumInitRaw, blockBeforeLoop);
	+ accum->addIncoming(accumInitRaw, blockProlog);
	llvm::PHINode *idxCurrentRaw = llvm->irBuilder.CreatePHI(idxBeginRaw->getType(), 2, "foldIt");
	- idxCurrentRaw->addIncoming(idxBeginRaw, blockBeforeLoop);
	+ idxCurrentRaw->addIncoming(idxBeginRaw, blockProlog);

	// * loop checks
	Value* condRange = llvm->irBuilder.CreateICmpNE(idxCurrentRaw, idxEndRaw);
	- llvm->irBuilder.CreateCondBr(condRange, blockLoopBody, blockAfterLoop);
	+ llvm->irBuilder.CreateCondBr(condRange, blockBody, blockEpilog);

	- // * loop body
	- llvm->irBuilder.SetInsertPoint(blockLoopBody);
	+ //Body:
	+ llvm->irBuilder.SetInsertPoint(blockBody);
	CodeScope* scopeLoop = loopE.blocks.front();
	compilation::IBruteScope* loopUnit = function->getScopeUnit(scopeLoop);
	Value* elIn = aggrItIR->get(aggrRaw, idxCurrentRaw);
	loopUnit->bindArg(accum, move(accumAlias));
	loopUnit->bindArg(elIn, move(elAlias));
	Value* accumNext = loopUnit->compile();

	// * Loop saturation checks
	- bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
	+ bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockFooter, blockEpilog, context);
	llvm::BasicBlock* blockSaturation = llvm->irBuilder.GetInsertBlock();
	if (!flagSaturationTriggered){
	- llvm->irBuilder.CreateBr(blockNext);
	+ llvm->irBuilder.CreateBr(blockFooter);
	}

	+ //Footer:
	// * computing next iteration state
	- llvm->irBuilder.SetInsertPoint(blockNext);
	+ llvm->irBuilder.SetInsertPoint(blockFooter);
	Value *itLoopNext = aggrItIR->advance(idxCurrentRaw);
	accum->addIncoming(accumNext, llvm->irBuilder.GetInsertBlock());
	idxCurrentRaw->addIncoming(itLoopNext, llvm->irBuilder.GetInsertBlock());
	- llvm->irBuilder.CreateBr(blockLoop);
	+ llvm->irBuilder.CreateBr(blockHeader);
	+
	+ //Prolog:
	+ llvm->irBuilder.SetInsertPoint(context.scope->lastBlockRaw);
	+ llvm->irBuilder.CreateBr(blockProlog);
	+
	+ llvm->irBuilder.SetInsertPoint(blockProlog);
	+ llvm->irBuilder.CreateBr(blockHeader);

	- // * finalization:
	- llvm->irBuilder.SetInsertPoint(blockAfterLoop);
	+ // Epilog:
	+ llvm->irBuilder.SetInsertPoint(blockEpilog);
	if (!flagSaturationTriggered){
	return accum;
	}

	llvm::PHINode* result = llvm->irBuilder.CreatePHI(accumRawT, 2, hintAlias);
	- result->addIncoming(accum, blockLoop);
	+ result->addIncoming(accum, blockHeader);
	result->addIncoming(accumNext, blockSaturation);

	return result;
	}

	llvm::Value*
	ControlIR::compileFoldInf(const Expression& fold, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	assert(fold.op == Operator::FOLD_INF);

	std::string accumName = fold.bindings[0];
	llvm::Value* accumInit = scope->process(fold.getOperands()[0]);

	llvm::BasicBlock *blockBeforeLoop = llvm->irBuilder.GetInsertBlock();
	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm->llvmContext, "foldinf", function->raw);
	llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm->llvmContext, "foldinf_next", function->raw);
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm->llvmContext, "foldinf_post", function->raw);
	std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));

	llvm->irBuilder.CreateBr(blockLoop);

	// * create phi
	llvm->irBuilder.SetInsertPoint(blockLoop);
	llvm::PHINode *accum = llvm->irBuilder.CreatePHI(accumInit->getType(), 2, accumName);
	accum->addIncoming(accumInit, blockBeforeLoop);

	// * loop body
	CodeScope* scopeLoop = fold.blocks.front();
	compilation::IBruteScope* unitLoop = function->getScopeUnit(scopeLoop);
	unitLoop->bindArg(accum, move(accumName));
	Value* accumNext = unitLoop->compile();

	// * Loop saturation checks
	bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
	assert(flagSaturationTriggered);

	// * computing next iteration state
	llvm->irBuilder.SetInsertPoint(blockNext);
	accum->addIncoming(accumNext, llvm->irBuilder.GetInsertBlock());
	llvm->irBuilder.CreateBr(blockLoop);

	// finalization:
	llvm->irBuilder.SetInsertPoint(blockAfterLoop);
	return accumNext;
	}

	llvm::Value*
	ControlIR::compileIf(const Expression& exprIf, const std::string& hintRetVar) {
	EXPAND_CONTEXT

	const Expression& condExpr = exprIf.getOperands()[0];
	llvm::IRBuilder<>& builder = llvm->irBuilder;
	- assert(builder.GetInsertBlock() == scope->currentBlockRaw);
	+ assert(builder.GetInsertBlock() == scope->lastBlockRaw);

	//initialization:
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm->llvmContext, "ifAfter", function->raw);
	llvm::BasicBlock *blockTrue = llvm::BasicBlock::Create(llvm->llvmContext, "ifTrue", function->raw);
	llvm::BasicBlock *blockFalse = llvm::BasicBlock::Create(llvm->llvmContext, "ifFalse", function->raw);

	llvm::Value* cond = scope->process(condExpr);

	builder.SetInsertPoint(blockTrue);
	CodeScope* scopeTrue = exprIf.blocks.front();
	llvm::Value* resultTrue = function->getScopeUnit(scopeTrue)->compile();
	llvm::BasicBlock * blockTrueEnd = builder.GetInsertBlock();
	builder.CreateBr(blockEpilog);

	builder.SetInsertPoint(blockFalse);
	CodeScope* scopeFalse = exprIf.blocks.back();
	llvm::Value* resultFalse = function->getScopeUnit(scopeFalse)->compile();
	llvm::BasicBlock * blockFalseEnd = builder.GetInsertBlock();
	builder.CreateBr(blockEpilog);

	- builder.SetInsertPoint(scope->currentBlockRaw);
	+ builder.SetInsertPoint(scope->lastBlockRaw);
	llvm->irBuilder.CreateCondBr(cond, blockTrue, blockFalse);

	builder.SetInsertPoint(blockEpilog);
	llvm::PHINode *ret = builder.CreatePHI(resultTrue->getType(), 2, NAME("if"));

	ret->addIncoming(resultTrue, blockTrueEnd);
	ret->addIncoming(resultFalse, blockFalseEnd);

	return ret;
	}

	//TODO Switch: default variant no needed when all possible conditions are considered
	llvm::Value*
	ControlIR::compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar) {
	EXPAND_CONTEXT UNUSED(function);
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->irBuilder;
	assert(exprSwitch.operands.size() >= 2);
	assert(exprSwitch.operands[1].op == Operator::CASE_DEFAULT && "No default case in Switch Statement");

	int countCases = exprSwitch.operands.size() - 1;
	llvm::BasicBlock* blockProlog = builder.GetInsertBlock();
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm->llvmContext, "switchAfter", function->raw);
	builder.SetInsertPoint(blockEpilog);
	llvm::Type* exprSwitchType = llvm->toLLVMType(root->getType(exprSwitch));
	llvm::PHINode *ret = builder.CreatePHI(exprSwitchType, countCases, NAME("switch"));
	llvm::Type* typI8 = llvm::Type::getInt8Ty(llvm->llvmContext);

	builder.SetInsertPoint(blockProlog);
	llvm::Value * conditionSwitch = scope->process(exprSwitch.operands[0]);
	llvm::BasicBlock *blockDefault = llvm::BasicBlock::Create(llvm->llvmContext, "caseDefault", function->raw);
	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(
	typeinference::doAutomaticTypeConversion(conditionSwitch, typI8, builder),
	blockDefault,
	countCases);

	for (int size = exprSwitch.operands.size(), i = 2; i < size; ++i) {
	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm->llvmContext, "case" + std::to_string(i), function->raw);

	llvm::Value* condCase = function->getScopeUnit(exprSwitch.operands[i].blocks.front())->compile();
	builder.SetInsertPoint(blockCase);
	llvm::Value* resultCase = function->getScopeUnit(exprSwitch.operands[i].blocks.back())->compile();
	builder.CreateBr(blockEpilog);

	ret->addIncoming(resultCase, builder.GetInsertBlock());
	builder.SetInsertPoint(blockProlog);
	instructionSwitch->addCase(
	dyn_cast<llvm::ConstantInt>(
	typeinference::doAutomaticTypeConversion(condCase, typI8, builder)),
	blockCase);
	}

	//compile default block:
	builder.SetInsertPoint(blockDefault);
	CodeScope* scopeDefault = exprSwitch.operands[1].blocks.front();
	llvm::Value* resultDefault = function->getScopeUnit(scopeDefault)->compile();
	builder.CreateBr(blockEpilog);
	ret->addIncoming(resultDefault, builder.GetInsertBlock());
	builder.SetInsertPoint(blockEpilog);

	return ret;
	}

	llvm::Value*
	ControlIR::compileSwitchVariant(const Expression& exprSwitch, const std::string& hintRetVar) {
	EXPAND_CONTEXT UNUSED(function);
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->irBuilder;
	llvm::Type* typI8= llvm::Type::getInt8Ty(llvm->llvmContext);
	const ExpandedType& typVariant = root->getType(exprSwitch.operands.at(0));
	llvm::Type* typVariantRaw = llvm->toLLVMType(typVariant);

	assert(typVariant->__operands.size() == exprSwitch.operands.size() - 1 && "Ill-formed Switch Variant");

	int casesCount = exprSwitch.operands.size();
	llvm::BasicBlock* blockProlog = builder.GetInsertBlock();
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm->llvmContext, "switchAfter", function->raw);
	builder.SetInsertPoint(blockEpilog);
	llvm::Type* resultType = llvm->toLLVMType(root->getType(exprSwitch));
	llvm::PHINode *ret = builder.CreatePHI(resultType, casesCount, NAME("switch"));

	builder.SetInsertPoint(blockProlog);
	llvm::Value * conditionSwitchRaw = scope->process(exprSwitch.operands.at(0));
	llvm::Value* idRaw = builder.CreateExtractValue(conditionSwitchRaw, llvm::ArrayRef<unsigned>({0}));

	//Dereference preparation
	const bool flagPrepareDerefence = std::any_of(typVariant->__operands.begin(), typVariant->__operands.end(), [](const TypeAnnotation& op){
	return op.isValid();
	});

	llvm::Value* addrAsStorage = nullptr;
	if (flagPrepareDerefence){
	assert(exprSwitch.bindings.size() && "Switch condition alias not found");
	llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(1);
	llvm::Value* storageRaw = builder.CreateExtractValue(conditionSwitchRaw, llvm::ArrayRef<unsigned>({1}));
	addrAsStorage = llvm->irBuilder.CreateAlloca(typStorageRaw);
	llvm->irBuilder.CreateStore(storageRaw, addrAsStorage);
	}

	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(idRaw, nullptr, casesCount);
	llvm::BasicBlock* blockDefaultUndefined;
	std::list<CodeScope*>::const_iterator scopeCaseIt = exprSwitch.blocks.begin();
	for (int instancesSize = exprSwitch.operands.size()-1, instId = 0; instId < instancesSize; ++instId) {
	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm->llvmContext, "case" + std::to_string(instId), function->raw);
	builder.SetInsertPoint(blockCase);
	IBruteScope* unitCase = function->getScopeUnit(*scopeCaseIt);
	const ExpandedType& instType = ExpandedType(typVariant->__operands.at(instId));

	//Actual variant derefence
	if (instType->isValid()) {
	string identCondition = exprSwitch.bindings.front();
	llvm::Type* instTypeRaw = llvm->toLLVMType(instType);
	llvm::Value* addrAsInst = llvm->irBuilder.CreateBitOrPointerCast(addrAsStorage, instTypeRaw->getPointerTo());
	llvm::Value* instRaw = llvm->irBuilder.CreateLoad(instTypeRaw, addrAsInst);
	const Symbol& identSymb = unitCase->bindArg(instRaw, move(identCondition));
	Attachments::put<TypeInferred>(identSymb, instType);
	}

	llvm::Value* resultCase = function->getScopeUnit(*scopeCaseIt)->compile();
	builder.CreateBr(blockEpilog);

	ret->addIncoming(resultCase, blockDefaultUndefined = builder.GetInsertBlock());
	builder.SetInsertPoint(blockProlog);
	instructionSwitch->addCase(dyn_cast<llvm::ConstantInt>(llvm::ConstantInt::get(typI8, exprSwitch.operands.at(instId+1).getValueDouble())), blockCase);
	++scopeCaseIt;
	}

	instructionSwitch->setDefaultDest(blockDefaultUndefined);
	builder.SetInsertPoint(blockEpilog);
	return ret;
	}

	llvm::Value*
	ControlIR::compileConstantStringAsPChar(const string& data, const std::string& hintRetVar) {
	EXPAND_CONTEXT UNUSED(function); UNUSED(scope);

	Type* typPchar = PointerType::getUnqual(Type::getInt8Ty(llvm->llvmContext));
	//ArrayType* typStr = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::I8, size+1))));

	/*
	std::vector<Constant *> chars;
	chars.reserve(size+1);

	for (size_t i=0; i< size; ++i){
	chars[i] = ConstantInt::get(typI8, (unsigned char) data[i]);
	}
	chars[size] = ConstantInt::get(typI8, 0);
	*/

	Value* rawData = ConstantDataArray::getString(llvm->llvmContext, data);
	Value* rawPtrData = llvm->irBuilder.CreateAlloca(rawData->getType(), ConstantInt::get(Type::getInt32Ty(llvm->llvmContext), 1, false));
	llvm->irBuilder.CreateStore(rawData, rawPtrData);
	return llvm->irBuilder.CreateCast(llvm::Instruction::BitCast, rawPtrData, typPchar, hintRetVar);
	}

	llvm::Value*
	ControlIR::compileSequence(const Expression &expr){
	EXPAND_CONTEXT UNUSED(scope); UNUSED(llvm);

	llvm::Value* result;
	for(CodeScope* scope: expr.blocks){
	result = function->getScopeUnit(scope)->compile();
	}

	return result;
	}


	diff --git a/cpp/src/compilation/demand.h b/cpp/src/compilation/demand.h
	index 9a9e64b..44e6f0c 100644
	--- a/cpp/src/compilation/demand.h
	+++ b/cpp/src/compilation/demand.h
	@@ -1,101 +1,101 @@
	/*
	* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*/

	/*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on June 23, 2018, 2:51 PM
	*
	*/

	#ifndef LATEX_H
	#define LATEX_H

	#include "query/demand.h"
	#include "analysis/utils.h"
	#include "pass/compilepass.h"

	namespace xreate{namespace demand{

	template<class Parent>
	class DemandBruteFnDecorator : public Parent{
	public:
	DemandBruteFnDecorator(ManagedFnPtr f, CompilePass *p): Parent(f, p){}

	protected:
	std::vector<llvm::Type *>
	prepareSignature() override{
	std::vector<llvm::Type *> &&signature = Parent::prepareSignature();

	DemandQuery* query = reinterpret_cast<DemandQuery *> (Parent::pass->man->transcend->getQuery(QueryId::DemandQuery));
	- const Demand& demand = query->getFnDemand(Parent::function->getName());
	+ const Demand& demand = query->getFnDemand(Parent::__function->getName());
	signature.reserve(signature.size() + demand.size());

	unsigned int argOffset = signature.size();
	for(const auto &rec: demand){
	TypeAnnotation argTCust(TypeOperator::ALIAS, {});
	argTCust.__valueCustom = rec.second;
	const ExpandedType &argT = Parent::pass->man->root->expandType(argTCust);
	Expression bindingE;
	- bindingE.type = argT;
	+ bindingE.type = argT.get();
	llvm::Type *argTRaw = Parent::pass->man->llvm->toLLVMType(argT);

	- Parent::function->addBinding(
	+ Parent::__function->addBinding(
	Atom<Identifier_t>(std::string(rec.first)),
	std::move(bindingE),
	argOffset++
	);
	signature.push_back(argTRaw);
	}

	return signature;
	}
	};

	/**
	* \brief Latex aware \ref xreate::compilation::IBruteScope decorator
	* \implements xreate::compilation::IBruteScope
	*/
	template<class Parent>
	class DemandBruteScopeDecorator : public Parent{
	public:
	DemandBruteScopeDecorator(const CodeScope const codeScope, compilation::IBruteFunction f, CompilePass *compilePass)
	: Parent(codeScope, f, compilePass){}

	compilation::IFnInvocation *
	findFunction(const Expression& opCall){
	DemandQuery* query = reinterpret_cast<DemandQuery *> (Parent::pass->man->transcend->getQuery(QueryId::DemandQuery));
	const std::string &calleeName = opCall.getValueString();
	compilation::IFnInvocation *opInvocBase = Parent::findFunction(opCall);

	const Demand &demand = query->getFnDemand(calleeName);
	if(!demand.size()) return opInvocBase;

	//prepare additional arguments
	std::vector<llvm::Value*> argsDemand;
	argsDemand.reserve(demand.size());

	const Supply& argsActual = query->getFnSupply(ASTSite{opCall.id});
	for(const auto& arg: demand){
	TypeAnnotation argTCust(TypeOperator::ALIAS, {});
	argTCust.__valueCustom = arg.second;
	const ExpandedType &argScheme = Parent::pass->man->root->expandType(argTCust);
	//llvm::Type* argSchemeRaw = Parent::pass->man->llvm->toLLVMType(argScheme);
	const Gringo::Symbol argTrAtom = argsActual.at(arg.first);
	Expression argE = analysis::representTransExpression(argTrAtom, argScheme, Parent::pass->man->transcend);
	- argE.type = argScheme;
	+ argE.type = argScheme.get();
	llvm::Value* argValueRaw = Parent::process(argE);

	argsDemand.push_back(argValueRaw);
	}

	return new compilation::HiddenArgsFnInvocation(std::move(argsDemand), opInvocBase);
	}
	};

	}} //end of namespace xreate::demand

	#endif /* LATEX_H */

	diff --git a/cpp/src/compilation/lambdas.cpp b/cpp/src/compilation/lambdas.cpp
	new file mode 100644
	index 0000000..f2d6ce1
	--- /dev/null
	+++ b/cpp/src/compilation/lambdas.cpp
	@@ -0,0 +1,65 @@
	+/* This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * File: lambdas.cpp
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ *
	+ * Created in April, 2020
	+ */
	+
	+#include "compilation/lambdas.h"
	+#include "llvmlayer.h"
	+#include "compilation/resources.h"
	+
	+using namespace xreate::compilation;
	+using namespace std;
	+
	+unsigned LambdaBruteFn::__counter = 0;
	+
	+std::string
	+LambdaBruteFn::prepareName(){
	+ return string(LAMBDA_PREFIX) + "_" + __hintAlias + "_" + to_string(__counter++);
	+}
	+
	+std::vector<llvm::Type*>
	+LambdaBruteFn::prepareSignature(){
	+ return getScopeSignature(IBruteFunction::__entry);
	+}
	+
	+llvm::Type*
	+LambdaBruteFn::prepareResult(){
	+ LLVMLayer* llvm = IBruteFunction::pass->man->llvm;
	+ AST* ast = IBruteFunction::pass->man->root;
	+
	+ return llvm->toLLVMType(ast->getType(__entry->getBody()));
	+}
	+
	+llvm::Function::arg_iterator
	+LambdaBruteFn::prepareBindings(){
	+ CodeScope* entry = IBruteFunction::__entry;
	+ IBruteScope* entryCompilation = IBruteFunction::getScopeUnit(entry);
	+ llvm::Function::arg_iterator fargsI = IBruteFunction::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;
	+}
	+
	+void
	+LambdaBruteFn::applyAttributes(){
	+ raw->addFnAttr(llvm::Attribute::AlwaysInline);
	+}
	+
	+llvm::Function*
	+LambdaIR::compile(CodeScope* body, const std::string& hintAlias){
	+ LambdaBruteFn fnLambda(body, __pass, hintAlias);
	+
	+ return fnLambda.compile();
	+}
	diff --git a/cpp/src/compilation/lambdas.h b/cpp/src/compilation/lambdas.h
	new file mode 100644
	index 0000000..900b151
	--- /dev/null
	+++ b/cpp/src/compilation/lambdas.h
	@@ -0,0 +1,52 @@
	+/* This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * File: lambdas.h
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ *
	+ * Created in April, 2020
	+ */
	+
	+#ifndef XREATE_LAMBDAS_H
	+#define XREATE_LAMBDAS_H
	+
	+#include "pass/compilepass.h"
	+
	+namespace llvm {
	+ class Function;
	+}
	+
	+namespace xreate { namespace compilation {
	+
	+class LambdaBruteFn: public IBruteFunction {
	+public:
	+ LambdaBruteFn(CodeScope* entry, CompilePass* p, const std::string& hintAlias)
	+ : IBruteFunction(entry, p), __hintAlias(hintAlias) {}
	+
	+protected:
	+ virtual std::string prepareName() override;
	+ virtual std::vector<llvm::Type*> prepareSignature() override;
	+ virtual llvm::Function::arg_iterator prepareBindings() override;
	+ virtual llvm::Type* prepareResult() override;
	+ virtual void applyAttributes() override;
	+
	+private:
	+ std::string __hintAlias;
	+ static unsigned __counter;
	+};
	+
	+class LambdaIR{
	+public:
	+ LambdaIR(CompilePass* p): __pass(p){}
	+ llvm::Function* compile(CodeScope* body, const std::string& hintAlias);
	+
	+private:
	+ compilation::Context __context;
	+ CompilePass* __pass;
	+
	+};
	+
	+}}
	+
	+#endif //XREATE_LAMBDAS_H
	diff --git a/cpp/src/compilation/resources.cpp b/cpp/src/compilation/resources.cpp
	new file mode 100644
	index 0000000..f7c6b43
	--- /dev/null
	+++ b/cpp/src/compilation/resources.cpp
	@@ -0,0 +1,15 @@
	+/* This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ * File: resources.h
	+ *
	+ * Created in April, 2020
	+ */
	+
	+#include "compilation/resources.h"
	+
	+namespace xreate{namespace compilation {
	+const char *LAMBDA_PREFIX = ".lmd";
	+}} // end of xreate::compilation
	\ No newline at end of file
	diff --git a/cpp/src/compilation/resources.h b/cpp/src/compilation/resources.h
	new file mode 100644
	index 0000000..319714a
	--- /dev/null
	+++ b/cpp/src/compilation/resources.h
	@@ -0,0 +1,20 @@
	+/* This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ * File: resources.h
	+ *
	+ * Created in April, 2020
	+ */
	+
	+#ifndef XREATE_RESOURCES_H
	+#define XREATE_RESOURCES_H
	+
	+#include <string>
	+
	+namespace xreate{namespace compilation{
	+extern const char *LAMBDA_PREFIX;
	+}} // end of xreate::compilation
	+
	+#endif //XREATE_RESOURCES_H
	diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
	index a41bac5..02d4b9d 100644
	--- a/cpp/src/compilation/targetinterpretation.cpp
	+++ b/cpp/src/compilation/targetinterpretation.cpp
	@@ -1,648 +1,648 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: targetinterpretation.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 29, 2016, 6:45 PM
	*/

	/**
	* \file targetinterpretation.h
	* \brief Interpretation support. See more details on [Interpretation](/d/concepts/interpretation/)
	*/

	#include "compilation/targetinterpretation.h"
	#include "pass/interpretationpass.h"
	#include "analysis/typeinference.h"
	#include "llvmlayer.h"
	#include "compilation/decorators.h"
	#include "compilation/i12ninst.h"
	#include "compilation/intrinsics.h"

	#include <boost/scoped_ptr.hpp>
	#include <iostream>
	#include <csignal>

	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));

	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((const CodeScope*) exprCase.blocks.front())->processScope() == exprCondition) {
	return exprCase.blocks.back();
	}
	}

	if (flagHasDefault) {
	const Expression& exprCaseDefault = expression.operands[1];
	return exprCaseDefault.blocks.front();
	}

	assert(false && "Switch has no appropriate variant");
	return nullptr;
	}

	CodeScope*
	InterpretationScope::processOperatorSwitchVariant(const Expression& expression) {
	const ExpandedType& conditionT = function->__pass->man->root->getType(expression.operands.at(0));
	const Expression& conditionE = process(expression.operands.at(0));
	assert(conditionE.op == Operator::VARIANT);
	const string& aliasS = expression.bindings.front();

	unsigned caseExpectedId = (int) conditionE.getValueDouble();
	auto itFoundValue = std::find_if(++expression.operands.begin(), expression.operands.end(), [caseExpectedId](const auto& caseActualE){
	return (unsigned) caseActualE.getValueDouble() == caseExpectedId;
	});
	assert(itFoundValue != expression.operands.end());

	int caseScopeId = itFoundValue - expression.operands.begin() - 1;
	auto caseScopeRef = expression.blocks.begin();
	std::advance(caseScopeRef, caseScopeId);
	InterpretationScope* scopeI12n = function->getScope(*caseScopeRef);

	if(conditionE.operands.size()) {
	Expression valueE(Operator::LIST, {});
	valueE.operands = conditionE.operands;
	valueE.bindings = conditionT->__operands.at(caseExpectedId).fields;

	scopeI12n->overrideBindings({
	{valueE, aliasS}
	});
	};

	return *caseScopeRef;
	}

	llvm::Value*
	InterpretationScope::processLate(const InterpretationOperator& op, const Expression& expression, const Context& context, const std::string& hintAlias) {
	switch(op) {
	case IF_INTERPRET_CONDITION:
	{
	CodeScope* scopeResult = processOperatorIf(expression);

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case SWITCH_INTERPRET_CONDITION:
	{
	CodeScope* scopeResult = processOperatorSwitch(expression);

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case SWITCH_VARIANT:
	{
	CodeScope* scopeResult = processOperatorSwitchVariant(expression);
	const Expression& condCrudeE = expression.operands.at(0);
	const Expression& condE = process(condCrudeE);

	const string identCondition = expression.bindings.front();
	auto scopeCompilation = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeResult));

	if(condE.operands.size()) {
	//override value
	Symbol symbCondition{ScopedSymbol{scopeResult->__identifiers.at(identCondition), versions::VERSION_NONE}, scopeResult};
	scopeCompilation->overrideDeclarations({
	{symbCondition, Expression(condE.operands.at(0))}}
	);

	//set correct type for binding:
	- TypeAnnotation typeVariant = function->__pass->man->root->getType(condCrudeE);
	+ const ExpandedType& typeVariant = function->__pass->man->root->getType(condCrudeE);
	int conditionIndex = condE.getValueDouble();
	ScopedSymbol symbolInternal = scopeResult->getSymbol(identCondition);
	- scopeResult->__declarations[symbolInternal].bindType(typeVariant.__operands.at(conditionIndex));
	+ scopeResult->__declarations[symbolInternal].bindType(typeVariant->__operands.at(conditionIndex));
	}

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case SWITCH_LATE:
	{
	return nullptr;
	// latereasoning::LateReasoningCompiler compiler(dynamic_cast<InterpretationFunction*>(this->function), context);
	// return compiler.processSwitchLateStatement(expression, "");
	}

	case FOLD_INTERPRET_INPUT:
	{
	//initialization
	const Expression& containerE = process(expression.getOperands().at(0));
	const TypeAnnotation& accumT = expression.type;
	assert(containerE.op == Operator::LIST);
	CodeScope* bodyScope = expression.blocks.front();
	const string& elAlias = expression.bindings[0];
	Symbol elS{ScopedSymbol{bodyScope->__identifiers.at(elAlias), versions::VERSION_NONE}, bodyScope};
	const std::string& accumAlias = expression.bindings[1];
	llvm::Value* accumRaw = context.scope->process(expression.getOperands().at(1), accumAlias, accumT);

	InterpretationScope* bodyI12n = function->getScope(bodyScope);
	auto bodyBrute = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(bodyScope));
	const std::vector<Expression>& containerVec = containerE.getOperands();

	for(size_t i = 0; i < containerVec.size(); ++i) {
	const Expression& elE = containerVec[i];

	bodyI12n->overrideBindings({
	{elE, elAlias}
	});
	bodyBrute->overrideDeclarations({
	{elS, elE}
	}); //resets bodyBrute
	bodyBrute->bindArg(accumRaw, string(accumAlias));

	accumRaw = bodyBrute->compile();
	accumRaw->getType()->print(llvm::outs());
	llvm::outs() << "\n\n";
	}

	return accumRaw;
	}

	// case FOLD_INF_INTERPRET_INOUT:
	// {
	// }

	//TODO refactor as InterpretationCallStatement class
	case CALL_INTERPRET_PARTIAL:
	{
	const std::string &calleeName = expression.getValueString();
	IBruteScope* scopeUnitSelf = context.scope;
	ManagedFnPtr callee = this->function->__pass->man->root->findFunction(calleeName);
	const I12nFunctionSpec& calleeData = FunctionInterpretationHelper::getSignature(callee);
	std::vector<llvm::Value *> argsActual;
	PIFnSignature 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->__pass);
	PIFunction* pifunction = man->getFunction(move(sig));

	llvm::Function* raw = pifunction->compile();
	boost::scoped_ptr<BruteFnInvocation> statement(new BruteFnInvocation(raw, man->pass->man->llvm));
	return (*statement)(move(argsActual));
	}

	case QUERY_LATE:
	{
	return nullptr;
	// return IntrinsicQueryInstruction(
	// dynamic_cast<InterpretationFunction*>(this->function))
	// .processLate(expression, context);
	}

	default: break;
	}

	assert(false && "Unknown late interpretation operator");
	return nullptr;
	}

	llvm::Value*
	InterpretationScope::compile(const Expression& expression, const Context& context, const std::string& hintAlias) {
	const InterpretationData& data = Attachments::get<InterpretationData>(expression);

	if (data.op != InterpretationOperator::NONE) {
	return processLate(data.op, expression, context, hintAlias);
	}

	Expression result = process(expression);
	return context.scope->process(result, hintAlias);
	}

	Expression
	InterpretationScope::process(const Expression& expression) {
	#ifndef NDEBUG
	if (expression.tags.count("bpoint")) {
	std::raise(SIGINT);
	}
	#endif

	PassManager* man = function->__pass->man;

	switch (expression.__state) {
	case Expression::INVALID:
	assert(false);

	case Expression::NUMBER:
	case Expression::STRING:
	return expression;

	case Expression::IDENT:
	{
	Symbol s = Attachments::get<IdentifierSymbol>(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 = man->root->findFunction(fnName);
	InterpretationFunction* fnUnit = this->function->__pass->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::CALL_INTRINSIC:
	{
	const Expression& opCallIntrCrude = expression;
	vector<Expression> argsActual;
	argsActual.reserve(opCallIntrCrude.getOperands().size());
	for(const auto& op: opCallIntrCrude.getOperands()) {
	argsActual.push_back(process(op));
	}

	Expression opCallIntr(Operator::CALL_INTRINSIC, {});
	opCallIntr.setValueDouble(opCallIntrCrude.getValueDouble());
	opCallIntr.operands = argsActual;

	compilation::IntrinsicCompiler compiler(man);
	return compiler.interpret(opCallIntr);
	}

	case Operator::QUERY:
	{
	return Expression();
	// return IntrinsicQueryInstruction(dynamic_cast<InterpretationFunction*>(this->function))
	// .process(expression);
	}

	case Operator::QUERY_LATE:
	{
	assert(false && "Can't be interpretated");
	return Expression();
	}

	case Operator::IF:
	{
	CodeScope* scopeResult = processOperatorIf(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::SWITCH:
	{
	CodeScope* scopeResult = processOperatorSwitch(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::SWITCH_VARIANT:
	{
	CodeScope* scopeResult = processOperatorSwitchVariant(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::VARIANT:
	{
	Expression result{Operator::VARIANT, {}};
	result.setValueDouble(expression.getValueDouble());

	for(const Expression& op: expression.operands){
	result.operands.push_back(process(op));
	}

	return result;
	}

	case Operator::INDEX:
	{
	Expression aggrE = process(expression.operands[0]);

	for (size_t keyId = 1; keyId < expression.operands.size(); ++keyId) {
	const Expression& keyE = process(expression.operands[keyId]);

	if (keyE.__state == Expression::STRING) {
	const string& fieldExpectedS = keyE.getValueString();
	unsigned fieldId;
	for(fieldId = 0; fieldId < aggrE.bindings.size(); ++fieldId){
	if (aggrE.bindings.at(fieldId) == fieldExpectedS){break;}
	}
	assert(fieldId < aggrE.bindings.size());
	aggrE = Expression(aggrE.operands.at(fieldId));
	continue;
	}

	if (keyE.__state == Expression::NUMBER) {
	int opId = keyE.getValueDouble();
	aggrE = Expression(aggrE.operands.at(opId));
	continue;
	}

	assert(false && "Inappropriate key");
	}

	return aggrE;
	}

	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->overrideBindings({
	{exprInput.getOperands()[i], argEl},
	{accum, argAccum}
	});

	accum = body->processScope();
	}

	return accum;
	}

	case Operator::LIST:
	case Operator::LIST_RANGE:
	{
	Expression result(expression.op,{});
	result.operands.resize(expression.operands.size());
	result.bindings = expression.bindings;

	int keyId = 0;
	for(const Expression& opCurrent : expression.operands) {
	result.operands[keyId++] = process(opCurrent);
	}

	return result;
	}

	// case Operator::MAP: {
	// break;
	// }

	default: break;
	}

	return expression;
	}

	InterpretationFunction*
	TargetInterpretation::getFunction(IBruteFunction* unit) {
	if (__dictFunctionsByUnit.count(unit)) {
	return __dictFunctionsByUnit.at(unit);
	}

	- InterpretationFunction* f = new InterpretationFunction(unit->function, this);
	+ InterpretationFunction* f = new InterpretationFunction(unit->getASTFn(), this);
	__dictFunctionsByUnit.emplace(unit, f);
	- assert(__functions.emplace(unit->function.id(), f).second);
	+ assert(__functions.emplace(unit->getASTFn().id(), f).second);

	return f;
	}

	PIFunction*
	TargetInterpretation::getFunction(PIFnSignature&& sig) {
	auto f = __pifunctions.find(sig);
	if (f != __pifunctions.end()) {
	return f->second;
	}

	PIFunction* result = new PIFunction(PIFnSignature(sig), __pifunctions.size(), this);
	__pifunctions.emplace(move(sig), result);
	assert(__dictFunctionsByUnit.emplace(result->fnRaw, 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, const std::string& hintAlias) {
	return transformContext(ctx)->compile(expression, ctx, hintAlias);
	}

	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);

	list<pair<Expression, string>> bindings;
	for(size_t i = 0, size = args.size(); i < size; ++i) {
	bindings.push_back(make_pair(args.at(i), body->scope->__bindings.at(i)));
	}

	body->overrideBindings(bindings);
	return body->processScope();
	}

	// Partial function interpretation

	typedef BasicBruteFunction BruteFunction;

	class PIBruteFunction : public BruteFunction{
	public:
	PIBruteFunction(ManagedFnPtr f, std::set<size_t>&& arguments, size_t id, CompilePass* p)
	: BruteFunction(f, p), argumentsActual(move(arguments)), __id(id) { }

	protected:
	std::vector<llvm::Type*>
	prepareSignature() override {
	LLVMLayer* llvm = BruteFunction::pass->man->llvm;
	AST* ast = BruteFunction::pass->man->root;
	- CodeScope* entry = BruteFunction::function->__entry;
	+ CodeScope* entry = IBruteFunction::__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() override{
	- CodeScope* entry = BruteFunction::function->__entry;
	+ CodeScope* entry = IBruteFunction::__entry;
	IBruteScope* entryCompilation = BruteFunction::getScopeUnit(entry);
	llvm::Function::arg_iterator fargsI = BruteFunction::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() override {
	return BruteFunction::prepareName() + "_" + std::to_string(__id);
	}

	private:
	std::set<size_t> argumentsActual;
	size_t __id;
	} ;

	PIFunction::PIFunction(PIFnSignature&& sig, size_t id, TargetInterpretation* target)
	: InterpretationFunction(sig.declaration, target), instance(move(sig)) {
	const I12nFunctionSpec& functionData = FunctionInterpretationHelper::getSignature(instance.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);
	}
	}

	fnRaw = new PIBruteFunction(instance.declaration, move(argumentsActual), id, target->pass);
	CodeScope* entry = instance.declaration->__entry;
	auto entryUnit = Decorators<CachedScopeDecoratorTag>::getInterface<>(fnRaw->getEntry());
	InterpretationScope* entryIntrp = InterpretationFunction::getScope(entry);

	list<pair<Expression, std::string>> bindingsPartial;
	list<pair<Symbol, Expression>> declsPartial;

	for(size_t no = 0, sigNo = 0, size = entry->__bindings.size(); no < size; ++no) {
	if(functionData.signature.at(no) == INTR_ONLY) {
	bindingsPartial.push_back({instance.bindings[sigNo], entry->__bindings[no]});

	VNameId argId = entry->__identifiers.at(entry->__bindings[no]);
	Symbol argSymbol{ScopedSymbol
	{argId, versions::VERSION_NONE}, entry};
	declsPartial.push_back({argSymbol, instance.bindings[sigNo]});
	++sigNo;
	}
	}

	entryIntrp->overrideBindings(bindingsPartial);
	entryUnit->overrideDeclarations(declsPartial);
	}

	llvm::Function*
	PIFunction::compile() {
	llvm::Function* raw = fnRaw->compile();

	return raw;
	}

	bool operator<(const PIFnSignature& lhs, const PIFnSignature& rhs) {
	if (lhs.declaration.id() != rhs.declaration.id()) {
	return lhs.declaration.id() < rhs.declaration.id();
	}

	return lhs.bindings < rhs.bindings;
	}

	bool operator<(const PIFnSignature& lhs, PIFunction * const rhs) {
	return lhs < rhs->instance;
	}

	bool operator<(PIFunction * const lhs, const PIFnSignature& rhs) {
	return lhs->instance < rhs;
	}

	}
	}

	/** \class xreate::interpretation::InterpretationFunction
	*
	* Holds list of xreate::interpretation::InterpretationScope 's focused on interpretation of individual code scopes
	*
	* There is particulat subclass PIFunction intended to represent partially interpreted functions.
	*\sa TargetInterpretation, [Interpretation Concept](/d/concepts/interpretation/)
	*/

	/** \class xreate::interpretation::TargetInterpretation
	*
	* TargetInterpretation is executed during compilation and is intended to preprocess eligible for interpretation parts of a source code.
	*
	* Keeps a list of InterpretationFunction / PIFunction that represent interpretation for an individual functions.
	*
	* There is \ref InterpretationScopeDecorator that embeds interpretation to an overall compilation process.
	* \sa InterpretationPass, compilation::Target, [Interpretation Concept](/d/concepts/interpretation/)
	*
	*/
	diff --git a/cpp/src/compilation/transformersaturation.cpp b/cpp/src/compilation/transformersaturation.cpp
	index 7dfc263..4f52f59 100644
	--- a/cpp/src/compilation/transformersaturation.cpp
	+++ b/cpp/src/compilation/transformersaturation.cpp
	@@ -1,84 +1,83 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* transformersaturation.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on March 25, 2017, 10:06 PM
	*/

	/**
	* \file transformersaturation.h
	* \brief Loop saturation support
	*/

	#include "transformersaturation.h"
	#include "llvmlayer.h"

	using namespace llvm;

	namespace xreate { namespace compilation {

	TransformerSaturation::TransformerSaturation(llvm::BasicBlock* allocationBlock, TransformationsManager* manager)
	: man(manager), blockAllocation(allocationBlock){

	if (man->exists<TransformerSaturation>()){
	oldInstance = man->update(this);

	} else {
	man->registerTransformer("final", this);
	}
	}

	TransformerSaturation::~TransformerSaturation(){
	if (oldInstance) {
	man->update(oldInstance);

	} else {
	man->unregisterTransformer("final", this);
	}
	}

	llvm::Value*
	TransformerSaturation::transform(const Expression& expression, llvm::Value* raw, const Context& ctx){
	processBreak(ctx);

	return raw;
	}

	-
	void
	TransformerSaturation::processBreak(const Context& ctx){
	allocateFlag(ctx);

	//show the saturation flag
	llvm::IRBuilder<>& builder = ctx.pass->man->llvm->irBuilder;
	llvm::Type* tyInt1 = llvm::Type::getInt1Ty(ctx.pass->man->llvm->llvmContext);
	llvm::Constant* constTrue = llvm::ConstantInt::get(tyInt1, 1);
	builder.CreateStore(constTrue, flagSaturation, true);
	}

	void
	TransformerSaturation::allocateFlag(const Context& ctx){
	//allocation of saturation flag
	IRBuilder<> builder(blockAllocation, blockAllocation->getFirstInsertionPt());
	llvm::Type* tyInt1 = llvm::Type::getInt1Ty(ctx.pass->man->llvm->llvmContext);

	llvm::Constant* constTrue = llvm::ConstantInt::get(tyInt1, 1);
	flagSaturation = builder.CreateAlloca(tyInt1, constTrue, "flagSaturation");
	llvm::Constant* constFalse = llvm::ConstantInt::get(tyInt1, 0);
	builder.CreateStore(constFalse, flagSaturation, true);
	}

	bool
	TransformerSaturation::insertSaturationChecks(llvm::BasicBlock* blockContinue, llvm::BasicBlock* blockExit, const Context& ctx){
	if (!flagSaturation) return false;

	llvm::IRBuilder<>& builder = ctx.pass->man->llvm->irBuilder;
	builder.CreateCondBr(builder.CreateLoad(flagSaturation), blockExit, blockContinue);

	return true;
	}

	} }
	diff --git a/cpp/src/llvmlayer.cpp b/cpp/src/llvmlayer.cpp
	index 930d6bf..ac179d8 100644
	--- a/cpp/src/llvmlayer.cpp
	+++ b/cpp/src/llvmlayer.cpp
	@@ -1,284 +1,283 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* llvmlayer.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file llvmlayer.h
	* \brief Bytecode generation
	*/

	#include "ast.h"
	#include "llvmlayer.h"
	#include "analysis/typehints.h"

	#ifdef XREATE_ENABLE_EXTERN
	#include "ExternLayer.h"
	#endif

	#include "llvm/ExecutionEngine/ExecutionEngine.h"
	#include "llvm/ExecutionEngine/MCJIT.h"
	#include "llvm/Support/TargetSelect.h"

	#include <iostream>
	#include <cmath>

	using namespace llvm;
	using namespace xreate;
	using namespace xreate::typehints;
	using namespace std;

	LLVMLayer::LLVMLayer(AST *root)
	: llvmContext(),
	irBuilder(llvmContext),
	ast(root),
	module(new llvm::Module(root->getModuleName(), llvmContext)){
	llvm::InitializeNativeTarget();
	llvm::InitializeNativeTargetAsmPrinter();
	llvm::EngineBuilder builder;
	TargetMachine *target = builder.selectTarget();
	module->setDataLayout(target->createDataLayout());

	#ifdef XREATE_ENABLE_EXTERN
	layerExtern = new ExternLayer(this);
	layerExtern->init(root);
	#endif
	}

	void *
	LLVMLayer::getFunctionPointer(llvm::Function *function){
	uint64_t entryAddr = jit->getFunctionAddress(function->getName().str());
	return (void *) entryAddr;
	}

	void
	LLVMLayer::initJit(){
	std::string ErrStr;
	llvm::EngineBuilder builder(std::unique_ptr<llvm::Module>(module.release()));
	jit.reset(builder
	.setEngineKind(llvm::EngineKind::JIT)
	.setErrorStr(&ErrStr)
	.setVerifyModules(true)
	.create()
	);
	}

	void
	LLVMLayer::print(){
	llvm::PassManager<llvm::Module> PM;
	PM.addPass(llvm::PrintModulePass(llvm::outs(), "banner"));
	llvm::AnalysisManager<llvm::Module> aman;
	PM.run(*module.get(), aman);
	}

	void
	LLVMLayer::moveToGarbage(void *o){
	__garbage.push_back(o);
	}

	llvm::Type*
	LLVMLayer::toLLVMType(const ExpandedType &ty) const{
	- TypeAnnotation t = ty;
	+ TypeAnnotation t = ty.get();
	switch(t.__operator){
	case TypeOperator::ARRAY:{
	//see ArrayIR::getRawT()
	return nullptr;
	}

	case TypeOperator::RECORD:{
	std::vector<llvm::Type *> packVec;
	packVec.reserve(t.__operands.size());

	std::transform(t.__operands.begin(), t.__operands.end(), std::inserter(packVec, packVec.end()),
	[this](const TypeAnnotation &t){
	return toLLVMType(ExpandedType(TypeAnnotation(t)));
	});

	llvm::ArrayRef<llvm::Type *> packArr(packVec);
	return llvm::StructType::get(llvmContext, packArr, false);
	};

	case TypeOperator::REF:{
	TypeAnnotation tyRef = t.__operands.at(0);
	assert(tyRef.__operator == TypeOperator::ALIAS);
	llvm::StructType *tyOpaqRaw = llvm::StructType::create(llvmContext, tyRef.__valueCustom);
	llvm::PointerType *tyRefRaw = llvm::PointerType::get(tyOpaqRaw, 0);

	return tyRefRaw;
	};

	case TypeOperator::ALIAS:{
	#ifdef XREATE_ENABLE_EXTERN
	//Look in extern types
	clang::QualType qt = layerExtern->lookupType(t.__valueCustom);
	return layerExtern->toLLVMType(qt);
	#else
	assert(false);
	#endif
	};

	//DEBT omit ID field in case of single variant.
	case TypeOperator::VARIANT:{
	/* Variant Type Layout:
	* {
	* id :: i8, Holds stored variant id
	* storage:: type of biggest variant
	* }
	*/
	uint64_t sizeStorage = 0;
	llvm::Type *typStorageRaw = llvm::Type::getVoidTy(llvmContext);
	for(const TypeAnnotation &subtype : t.__operands){
	llvm::Type *subtypeRaw = toLLVMType(ExpandedType(subtype));
	if(subtypeRaw->isVoidTy()) continue;

	uint64_t sizeSubtype = module->getDataLayout().getTypeStoreSize(subtypeRaw);
	if(sizeSubtype > sizeStorage){
	sizeStorage = sizeSubtype;
	typStorageRaw = subtypeRaw;
	}
	}

	std::vector<llvm::Type *> layout;
	layout.push_back(llvm::Type::getInt8Ty(llvmContext)); //id

	const bool flagHoldsData = sizeStorage > 0;
	if(flagHoldsData){
	layout.push_back(typStorageRaw); //storage
	}

	return llvm::StructType::get(llvmContext, llvm::ArrayRef<llvm::Type *>(layout));
	}

	case TypeOperator::NONE:{
	switch(t.__value){
	case TypePrimitive::Bool:
	return llvm::Type::getInt1Ty(llvmContext);

	case TypePrimitive::I8:
	return llvm::Type::getInt8Ty(llvmContext);

	case TypePrimitive::I32:
	return llvm::Type::getInt32Ty(llvmContext);

	case TypePrimitive::I64:
	return llvm::Type::getInt64Ty(llvmContext);

	case TypePrimitive::Int: {
	// IntBits hintSize;
	// if (existsSize(hintSize)){
	// return llvm::IntegerType::getIntNTy(llvmContext, hintSize.n);
	// }

	TypesHelper helper(this);
	return helper.getPreferredIntTy();
	}

	case TypePrimitive::Float:
	return llvm::Type::getDoubleTy(llvmContext);

	case TypePrimitive::String:
	return llvm::Type::getInt8PtrTy(llvmContext);

	case TypePrimitive::Invalid:
	return llvm::Type::getVoidTy(llvmContext);

	default:
	assert(false);
	}
	}

	default:
	assert(false);
	}

	assert(false);
	return nullptr;
	}

	bool
	TypesHelper::isRecordT(const ExpandedType &ty){
	const TypeAnnotation &t = ty.get();

	if(t.__operator == TypeOperator::RECORD){
	return true;
	}

	if(t.__operator != TypeOperator::ALIAS){
	return false;
	}

	#ifdef XREATE_ENABLE_EXTERN
	clang::QualType tqual = llvm->layerExtern->lookupType(t.__valueCustom);
	const clang::Type * raw = tqual.getTypePtr();

	// TODO skip ALL the pointers until non-pointer type found
	if (raw->isStructureType()) return true;
	if (!raw->isAnyPointerType()) return false;

	clang::QualType pointee = raw->getPointeeType();
	return pointee->isStructureType();
	#else
	assert(false);
	return false;
	#endif
	}

	bool
	TypesHelper::isArrayT(const Expanded<TypeAnnotation>& ty){
	const TypeAnnotation &t = ty.get();

	if(t.__operator == TypeOperator::ARRAY){
	return true;
	}

	return false;
	}

	bool
	TypesHelper::isPointerT(const ExpandedType &ty){
	if(ty.get().__operator != TypeOperator::ALIAS) return false;

	#ifdef XREATE_ENABLE_EXTERN
	clang::QualType qt = llvm->layerExtern->lookupType(ty.get().__valueCustom);
	return llvm->layerExtern->isPointer(qt);
	#else
	assert(false);
	return false;
	#endif
	}

	-
	bool
	TypesHelper::isIntegerT(const Expanded<TypeAnnotation>& ty){
	return
	(ty->__operator == TypeOperator::NONE) &&
	((ty->__value == TypePrimitive::Bool) \|\|
	(ty->__value == TypePrimitive::I8) \|\|
	(ty->__value == TypePrimitive::I32) \|\|
	(ty->__value == TypePrimitive::I64) \|\|
	(ty->__value == TypePrimitive::Int));
	}


	std::vector<std::string>
	TypesHelper::getRecordFields(const ExpandedType &t){
	#ifdef XREATE_ENABLE_EXTERN
	return (t.get().__operator == TypeOperator::RECORD)
	? t.get().fields
	: llvm->layerExtern->getStructFields(
	llvm->layerExtern->lookupType(t.get().__valueCustom));
	#else
	assert(t.get().__operator == TypeOperator::RECORD);
	return t.get().fields;
	#endif
	}

	llvm::IntegerType *
	TypesHelper::getPreferredIntTy() const{
	unsigned sizePreferred = llvm->module->getDataLayout().getLargestLegalIntTypeSizeInBits();
	return llvm::IntegerType::getIntNTy(llvm->llvmContext, sizePreferred);
	}
	\ No newline at end of file
	diff --git a/cpp/src/llvmlayer.h b/cpp/src/llvmlayer.h
	index c93fc53..410cb25 100644
	--- a/cpp/src/llvmlayer.h
	+++ b/cpp/src/llvmlayer.h
	@@ -1,73 +1,71 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* llvmlayer.h
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#ifndef LLVMLAYER_H
	#define LLVMLAYER_H

	#include "llvm/IR/Module.h"
	#include "llvm/IR/Function.h"
	#include "llvm/IR/PassManager.h"
	#include "llvm/IR/CallingConv.h"
	#include "llvm/IR/Verifier.h"
	#include "llvm/IR/IRPrintingPasses.h"
	#include "llvm/IR/IRBuilder.h"
	#include "llvm/Support/raw_ostream.h"
	#include "llvm/IR/LLVMContext.h"
	#include "llvm/ExecutionEngine/ExecutionEngine.h"
	#include "utils.h"

	namespace xreate {

	class AST;
	class ExternLayer;
	class TypeAnnotation;

	/** \brief A wrapper over LLVM toolchain to generate and execute bytecode */
	class LLVMLayer {
	public:
	LLVMLayer(AST* rootAST);

	mutable llvm::LLVMContext llvmContext;
	llvm::IRBuilder<> irBuilder;
	AST *ast = 0;
	ExternLayer *layerExtern =0;
	std::unique_ptr<llvm::Module> module;
	std::unique_ptr<llvm::ExecutionEngine> jit;

	void moveToGarbage(void *o);
	llvm::Type* toLLVMType(const Expanded<TypeAnnotation>& ty) const;
	void print();
	void* getFunctionPointer(llvm::Function* function);

	void initJit();

	private:
	llvm::Type* toLLVMType(const Expanded<TypeAnnotation>& ty, std::map<int, llvm::StructType*>& conjunctions) const;
	std::vector<void *> __garbage;
	};

	class TypesHelper {
	public:
	bool isArrayT(const Expanded<TypeAnnotation>& ty);
	bool isRecordT(const Expanded<TypeAnnotation>& ty);
	bool isPointerT(const Expanded<TypeAnnotation>& ty);
	-
	bool isIntegerT(const Expanded<TypeAnnotation>& ty);
	llvm::IntegerType* getPreferredIntTy() const;
	-
	std::vector<std::string> getRecordFields(const Expanded<TypeAnnotation>& t);

	TypesHelper(const LLVMLayer* llvmlayer): llvm(llvmlayer){}

	private:
	const LLVMLayer* llvm;
	};

	}
	#endif // LLVMLAYER_H
	diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
	index 35c2355..e3a6fc4 100644
	--- a/cpp/src/pass/compilepass.cpp
	+++ b/cpp/src/pass/compilepass.cpp
	@@ -1,850 +1,879 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* compilepass.cpp
	*/

	/**
	* \file compilepass.h
	* \brief Main compilation routine. See \ref xreate::CompilePass
	*/

	#include "compilepass.h"
	#include "transcendlayer.h"
	#include "ast.h"
	#include "llvmlayer.h"

	#include "compilation/decorators.h"
	#include "compilation/pointers.h"
	#include "analysis/typeinference.h"
	#include "compilation/control.h"
	#include "compilation/demand.h"
	#include "analysis/resources.h"
	#ifdef XREATE_ENABLE_EXTERN
	#include "ExternLayer.h"
	#endif

	#include "compilation/containers.h"
	#include "compilation/containers/arrays.h"

	#ifndef XREATE_CONFIG_MIN
	#include "query/containers.h"

	#include "pass/versionspass.h"
	#include "compilation/targetinterpretation.h"
	#endif

	#include <boost/optional.hpp>
	#include <memory>

	using namespace std;
	using namespace llvm;
	+using namespace xreate::typehints;
	+using namespace xreate::containers;

	namespace xreate{
	namespace compilation{
	-
	#define DEFAULT(x) (hintAlias.empty()? x: hintAlias)

	std::string
	BasicBruteFunction::prepareName() {
	AST* ast = IBruteFunction::pass->man->root;

	- string name = ast->getFnSpecializations(IBruteFunction::function->__name).size() > 1 ?
	- IBruteFunction::function->__name + std::to_string(IBruteFunction::function.id()) :
	- IBruteFunction::function->__name;
	+ string name = ast->getFnSpecializations(__function->__name).size() > 1 ?
	+ __function->__name + std::to_string(__function.id()) :
	+ __function->__name;

	return name;
	}

	std::vector<llvm::Type*>
	BasicBruteFunction::prepareSignature() {
	- LLVMLayer* llvm = IBruteFunction::pass->man->llvm;
	- AST* ast = IBruteFunction::pass->man->root;
	- CodeScope* entry = IBruteFunction::function->__entry;
	- std::vector<llvm::Type*> signature;
	+ CodeScope* entry = __function->__entry;

	- 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;
	+ return getScopeSignature(entry);
	}

	llvm::Type*
	BasicBruteFunction::prepareResult() {
	LLVMLayer* llvm = IBruteFunction::pass->man->llvm;
	AST* ast = IBruteFunction::pass->man->root;
	- CodeScope* entry = IBruteFunction::function->__entry;
	+ CodeScope* entry = __function->__entry;

	return llvm->toLLVMType(ast->expandType(entry->__declarations.at(ScopedSymbol::RetSymbol).type));
	}

	llvm::Function::arg_iterator
	BasicBruteFunction::prepareBindings() {
	- CodeScope* entry = IBruteFunction::function->__entry;
	+ CodeScope* entry = __function->__entry;
	IBruteScope* entryCompilation = IBruteFunction::getScopeUnit(entry);
	llvm::Function::arg_iterator fargsI = IBruteFunction::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;
	}

	+void
	+BasicBruteFunction::applyAttributes(){}
	+
	IBruteScope::IBruteScope(const CodeScope * const codeScope, IBruteFunction* f, CompilePass* compilePass)
	-: pass(compilePass), function(f), scope(codeScope), currentBlockRaw(nullptr) { }
	+: pass(compilePass), function(f), scope(codeScope), lastBlockRaw(nullptr) { }

	llvm::Value*
	BruteFnInvocation::operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	- llvm::Function* calleeInfo = dyn_cast<llvm::Function>(__callee);
	-
	- if (calleeInfo) {
	- auto argsFormal = calleeInfo->args();
	- size_t sizeArgsF = std::distance(argsFormal.begin(), argsFormal.end());
	- assert(args.size() >= sizeArgsF);
	- assert(calleeInfo->isVarArg() \|\| args.size() == sizeArgsF);
	-
	- auto argFormal = argsFormal.begin();
	- for(size_t argId = 0; argId < args.size(); ++argId){
	- if(argFormal != argsFormal.end()){
	- args[argId] = typeinference::doAutomaticTypeConversion(
	- args.at(argId), argFormal->getType(), llvm->irBuilder);
	- ++argFormal;
	- }
	- }
	- }
	-
	- //Do not name function call that returns Void.
	- std::string nameStatement = hintDecl;
	- if (calleeInfo->getReturnType()->isVoidTy()) {
	- nameStatement.clear();
	+ if (__calleeTy) {
	+ auto argsFormalT = __calleeTy->params();
	+ size_t sizeArgsF = __calleeTy->getNumParams();
	+ assert(args.size() >= sizeArgsF);
	+ assert(__calleeTy->isVarArg() \|\| args.size() == sizeArgsF);
	+
	+ auto argFormalT = argsFormalT.begin();
	+ for(size_t argId = 0; argId < args.size(); ++argId){
	+ if(argFormalT != argsFormalT.end()){
	+ args[argId] = typeinference::doAutomaticTypeConversion(
	+ args.at(argId), *argFormalT, llvm->irBuilder);
	+ ++argFormalT;
	+ }
	}
	+ }

	- return llvm->irBuilder.CreateCall(__calleeTy, __callee, args, nameStatement);
	+ //Do not name function call that returns Void.
	+ std::string hintName = (!__calleeTy->getReturnType()->isVoidTy()) ? hintDecl : "";
	+ return llvm->irBuilder.CreateCall(__calleeTy, __callee, args, hintName);
	}

	llvm::Value*
	HiddenArgsFnInvocation::operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	args.insert(args.end(), __args.begin(), __args.end());
	return __parent->operator ()(std::move(args), hintDecl);
	}

	class CallStatementInline : public IFnInvocation{
	public:

	CallStatementInline(IBruteFunction* caller, IBruteFunction* callee, LLVMLayer* l)
	: __caller(caller), __callee(callee), llvm(l) { }

	llvm::Value* operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	return nullptr;
	}

	private:
	IBruteFunction* __caller;
	IBruteFunction* __callee;
	LLVMLayer* llvm;

	bool
	isInline() {
	// Symbol ret = Symbol{0, function->__entry};
	// bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
	//TODO consider inlining
	return false;
	}
	} ;

	BasicBruteScope::BasicBruteScope(const CodeScope * const codeScope, IBruteFunction* f, CompilePass* compilePass)
	: IBruteScope(codeScope, f, compilePass) { }

	llvm::Value*
	BasicBruteScope::processSymbol(const Symbol& s, std::string hintRetVar) {
	- Expression declaration = CodeScope::getDefinition(s);
	- const CodeScope* scopeExternal = s.scope;
	- IBruteScope* scopeBruteExternal = IBruteScope::function->getScopeUnit(scopeExternal);
	- assert(scopeBruteExternal->currentBlockRaw);
	-
	- llvm::Value* resultRaw;
	- llvm::BasicBlock* blockOwn = pass->man->llvm->irBuilder.GetInsertBlock();
	-
	- if (scopeBruteExternal->currentBlockRaw == blockOwn) {
	- resultRaw = scopeBruteExternal->process(declaration, hintRetVar);
	- scopeBruteExternal->currentBlockRaw = currentBlockRaw =
	- pass->man->llvm->irBuilder.GetInsertBlock();
	-
	- } else {
	- pass->man->llvm->irBuilder.SetInsertPoint(scopeBruteExternal->currentBlockRaw);
	- resultRaw = scopeBruteExternal->processSymbol(s, hintRetVar);
	- pass->man->llvm->irBuilder.SetInsertPoint(blockOwn);
	- }
	+ Expression declaration = CodeScope::getDefinition(s);
	+ const CodeScope* scopeExternal = s.scope;
	+ IBruteScope* scopeBruteExternal = IBruteScope::function->getScopeUnit(scopeExternal);
	+ assert(scopeBruteExternal->lastBlockRaw);
	+
	+ llvm::Value* resultRaw;
	+ llvm::BasicBlock* blockOwn = pass->man->llvm->irBuilder.GetInsertBlock();
	+
	+ if (scopeBruteExternal->lastBlockRaw == blockOwn) {
	+ resultRaw = scopeBruteExternal->process(declaration, hintRetVar);
	+ scopeBruteExternal->lastBlockRaw = lastBlockRaw =
	+ pass->man->llvm->irBuilder.GetInsertBlock();
	+
	+ } else {
	+ pass->man->llvm->irBuilder.SetInsertPoint(scopeBruteExternal->lastBlockRaw);
	+ resultRaw = scopeBruteExternal->processSymbol(s, hintRetVar);
	+ pass->man->llvm->irBuilder.SetInsertPoint(blockOwn);
	+ }

	- return resultRaw;
	+ return resultRaw;
	}

	IFnInvocation*
	BasicBruteScope::findFunction(const Expression& opCall) {
	const std::string& calleeName = opCall.getValueString();
	LLVMLayer* llvm = pass->man->llvm;
	const std::list<ManagedFnPtr>& specializations = pass->man->root->getFnSpecializations(calleeName);

	#ifdef XREATE_ENABLE_EXTERN
	//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 BruteFnInvocation(external, llvm);
	}
	#endif

	//There should be only one specialization without any valid guards at this point
	return new BruteFnInvocation(pass->getFunctionUnit(
	pass->man->root->findFunction(calleeName))->compile(),
	llvm);
	}

	//DISABLEDFEATURE transformations
	// if (pass->transformations->isAcceptable(expr)){
	// return pass->transformations->transform(expr, result, ctx);
	// }

	llvm::Value*
	BasicBruteScope::process(const Expression& expr, const std::string& hintAlias, const TypeAnnotation& expectedT) {
	- llvm::Value *leftRaw;
	- llvm::Value *rightRaw;
	- LLVMLayer& l = *pass->man->llvm;
	- Context ctx{this, function, pass};
	- xreate::compilation::ControlIR controlIR = xreate::compilation::ControlIR({this, function, pass});
	-
	- switch (expr.op) {
	- case Operator::ADD:
	- case Operator::SUB: case Operator::MUL: case Operator::MOD:
	- 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);
	-
	- leftRaw = process(expr.operands.at(0));
	- rightRaw = process(expr.operands.at(1));
	-
	- break;
	+ llvm::Value *leftRaw;
	+ llvm::Value *rightRaw;
	+ LLVMLayer& l = *pass->man->llvm;
	+ Context ctx{this, function, pass};
	+ xreate::compilation::ControlIR controlIR = xreate::compilation::ControlIR({this, function, pass});
	+
	+ switch (expr.op) {
	+ case Operator::ADD:
	+ case Operator::SUB: case Operator::MUL: case Operator::MOD:
	+ 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);
	+
	+ leftRaw = process(expr.operands.at(0));
	+ rightRaw = process(expr.operands.at(1));
	+
	+ break;
	+
	+ default:;
	+ }

	- default:;
	+ switch (expr.op) {
	+ case Operator::AND:
	+ {
	+ assert(expr.operands.size());
	+ llvm::Value* resultRaw = process(expr.operands[0]);
	+ for(size_t i=1; i< expr.operands.size()-1; ++i){
	+ resultRaw = l.irBuilder.CreateAnd(resultRaw, process(expr.operands.at(i)));
	}
	+ return l.irBuilder.CreateAnd(resultRaw, process(expr.operands.at(expr.operands.size()-1)), hintAlias);
	+ }

	- switch (expr.op) {
	- case Operator::AND:
	- {
	- assert(expr.operands.size());
	- llvm::Value* resultRaw = process(expr.operands[0]);
	- for(size_t i=1; i< expr.operands.size()-1; ++i){
	- resultRaw = l.irBuilder.CreateAnd(resultRaw, process(expr.operands.at(i)));
	- }
	- return l.irBuilder.CreateAnd(resultRaw, process(expr.operands.at(expr.operands.size()-1)), hintAlias);
	+ case Operator::OR:
	+ {
	+ assert(expr.operands.size());
	+ llvm::Value* resultRaw = process(expr.operands[0]);
	+ for(size_t i=1; i< expr.operands.size()-1; ++i){
	+ resultRaw = l.irBuilder.CreateOr(resultRaw, process(expr.operands.at(i)));
	}
	+ return l.irBuilder.CreateOr(resultRaw, process(expr.operands.at(expr.operands.size()-1)), hintAlias);
	+ }

	- case Operator::OR:
	- {
	- assert(expr.operands.size());
	- llvm::Value* resultRaw = process(expr.operands[0]);
	- for(size_t i=1; i< expr.operands.size()-1; ++i){
	- resultRaw = l.irBuilder.CreateOr(resultRaw, process(expr.operands.at(i)));
	- }
	- return l.irBuilder.CreateOr(resultRaw, process(expr.operands.at(expr.operands.size()-1)), hintAlias);
	- }
	+ case Operator::ADD:
	+ {
	+ return l.irBuilder.CreateAdd(leftRaw, rightRaw, DEFAULT("addv"));
	+ }

	- case Operator::ADD:
	- {
	- return l.irBuilder.CreateAdd(leftRaw, rightRaw, DEFAULT("addv"));
	- }
	+ case Operator::SUB:
	+ return l.irBuilder.CreateSub(leftRaw, rightRaw, DEFAULT("tmp_sub"));
	+ break;

	- case Operator::SUB:
	- return l.irBuilder.CreateSub(leftRaw, rightRaw, DEFAULT("tmp_sub"));
	- break;
	+ case Operator::MUL:
	+ return l.irBuilder.CreateMul(leftRaw, rightRaw, DEFAULT("tmp_mul"));
	+ break;

	- case Operator::MUL:
	- return l.irBuilder.CreateMul(leftRaw, rightRaw, DEFAULT("tmp_mul"));
	- break;
	+ case Operator::DIV:
	+ if (leftRaw->getType()->isIntegerTy()) return l.irBuilder.CreateSDiv(leftRaw, rightRaw, DEFAULT("tmp_div"));
	+ if (leftRaw->getType()->isFloatingPointTy()) return l.irBuilder.CreateFDiv(leftRaw, rightRaw, DEFAULT("tmp_div"));
	+ break;

	- case Operator::DIV:
	- if (leftRaw->getType()->isIntegerTy()) return l.irBuilder.CreateSDiv(leftRaw, rightRaw, DEFAULT("tmp_div"));
	- if (leftRaw->getType()->isFloatingPointTy()) return l.irBuilder.CreateFDiv(leftRaw, rightRaw, DEFAULT("tmp_div"));
	- break;
	+ case Operator::MOD:{
	+ return l.irBuilder.CreateSRem(leftRaw, rightRaw, hintAlias);
	+ }
	+
	+ case Operator::EQU: {
	+ if (leftRaw->getType()->isIntegerTy()) return l.irBuilder.CreateICmpEQ(leftRaw, rightRaw, DEFAULT("tmp_equ"));
	+ if (leftRaw->getType()->isFloatingPointTy()) return l.irBuilder.CreateFCmpOEQ(leftRaw, rightRaw, DEFAULT("tmp_equ"));
	+
	+ const ExpandedType& leftT = pass->man->root->getType(expr.operands[0]);
	+ const ExpandedType& rightT = pass->man->root->getType(expr.operands[1]);

	- case Operator::MOD:{
	- return l.irBuilder.CreateSRem(leftRaw, rightRaw, hintAlias);
	+ if(leftT->__operator == TypeOperator::VARIANT && rightT->__operator == TypeOperator::VARIANT){
	+ llvm::Type* selectorT = llvm::cast<llvm::StructType>(leftRaw->getType())->getElementType(0);
	+ llvm::Value* leftUnwapped = typeinference::doAutomaticTypeConversion(leftRaw, selectorT, l.irBuilder);
	+ llvm::Value* rightUnwapped = typeinference::doAutomaticTypeConversion(rightRaw, selectorT, l.irBuilder);
	+ return l.irBuilder.CreateICmpEQ(leftUnwapped, rightUnwapped, DEFAULT("tmp_equ"));
	}
	+ break;
	+ }

	- case Operator::EQU: {
	- if (leftRaw->getType()->isIntegerTy()) return l.irBuilder.CreateICmpEQ(leftRaw, rightRaw, DEFAULT("tmp_equ"));
	- if (leftRaw->getType()->isFloatingPointTy()) return l.irBuilder.CreateFCmpOEQ(leftRaw, rightRaw, DEFAULT("tmp_equ"));
	+ case Operator::NE:
	+ return l.irBuilder.CreateICmpNE(leftRaw, rightRaw, DEFAULT("tmp_ne"));
	+ break;

	- const ExpandedType& leftT = pass->man->root->getType(expr.operands[0]);
	- const ExpandedType& rightT = pass->man->root->getType(expr.operands[1]);
	+ case Operator::LSS:
	+ return l.irBuilder.CreateICmpSLT(leftRaw, rightRaw, DEFAULT("tmp_lss"));
	+ break;

	- if(leftT->__operator == TypeOperator::VARIANT && rightT->__operator == TypeOperator::VARIANT){
	- llvm::Type* selectorT = llvm::cast<llvm::StructType>(leftRaw->getType())->getElementType(0);
	- llvm::Value* leftUnwapped = typeinference::doAutomaticTypeConversion(leftRaw, selectorT, l.irBuilder);
	- llvm::Value* rightUnwapped = typeinference::doAutomaticTypeConversion(rightRaw, selectorT, l.irBuilder);
	- return l.irBuilder.CreateICmpEQ(leftUnwapped, rightUnwapped, DEFAULT("tmp_equ"));
	- }
	- break;
	- }
	+ case Operator::LSE:
	+ return l.irBuilder.CreateICmpSLE(leftRaw, rightRaw, DEFAULT("tmp_lse"));
	+ break;

	- case Operator::NE:
	- return l.irBuilder.CreateICmpNE(leftRaw, rightRaw, DEFAULT("tmp_ne"));
	- break;
	+ case Operator::GTR:
	+ return l.irBuilder.CreateICmpSGT(leftRaw, rightRaw, DEFAULT("tmp_gtr"));
	+ break;

	- case Operator::LSS:
	- return l.irBuilder.CreateICmpSLT(leftRaw, rightRaw, DEFAULT("tmp_lss"));
	- break;
	+ case Operator::GTE:
	+ return l.irBuilder.CreateICmpSGE(leftRaw, rightRaw, DEFAULT("tmp_gte"));
	+ break;

	- case Operator::LSE:
	- return l.irBuilder.CreateICmpSLE(leftRaw, rightRaw, DEFAULT("tmp_lse"));
	- break;
	+ case Operator::NEG:
	+ {
	+ leftRaw = process(expr.operands[0]);
	+ ExpandedType leftTy = pass->man->root->getType(expr.operands[0]);

	- case Operator::GTR:
	- return l.irBuilder.CreateICmpSGT(leftRaw, rightRaw, DEFAULT("tmp_gtr"));
	- break;
	+ if (leftTy->__value == TypePrimitive::Bool){
	+ return l.irBuilder.CreateNot(leftRaw, hintAlias);
	+ } else {
	+ return l.irBuilder.CreateNeg(leftRaw, hintAlias);
	+ }
	+ break;
	+ }

	- case Operator::GTE:
	- return l.irBuilder.CreateICmpSGE(leftRaw, rightRaw, DEFAULT("tmp_gte"));
	- break;
	+ case Operator::CALL:
	+ {
	+ assert(expr.__state == Expression::COMPOUND);
	+ shared_ptr<IFnInvocation> callee(findFunction(expr));
	+ const std::string& nameCallee = expr.getValueString();

	- case Operator::NEG:
	- {
	- leftRaw = process(expr.operands[0]);
	- ExpandedType leftTy = pass->man->root->getType(expr.operands[0]);
	-
	- if (leftTy->__value == TypePrimitive::Bool){
	- return l.irBuilder.CreateNot(leftRaw, hintAlias);
	- } else {
	- return l.irBuilder.CreateNeg(leftRaw, hintAlias);
	+ //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);
	}
	- break;
	- }
	+ );

	- case Operator::CALL:
	- {
	- assert(expr.__state == Expression::COMPOUND);
	- shared_ptr<IFnInvocation> callee(findFunction(expr));
	- const std::string& nameCallee = expr.getValueString();
	+ return (*callee)(move(args), DEFAULT("res_" + nameCallee));
	+ }

	- //prepare arguments
	- std::vector<llvm::Value *> args;
	- args.reserve(expr.operands.size());
	+ case Operator::IF:
	+ {
	+ return controlIR.compileIf(expr, DEFAULT("tmp_if"));
	+ }

	- std::transform(expr.operands.begin(), expr.operands.end(), std::inserter(args, args.end()),
	- [this](const Expression & operand) {
	- return process(operand);
	- }
	- );
	+ case Operator::SWITCH:
	+ {
	+ return controlIR.compileSwitch(expr, DEFAULT("tmp_switch"));
	+ }

	- return (*callee)(move(args), DEFAULT("res_" + nameCallee));
	- }
	+ case Operator::LOGIC_AND:
	+ {
	+ assert(expr.operands.size() == 1);
	+ return process(expr.operands[0]);
	+ }

	- case Operator::IF:
	- {
	- return controlIR.compileIf(expr, DEFAULT("tmp_if"));
	- }
	+ case Operator::LIST: //init record or array
	+ {
	+ ExpandedType exprT = l.ast->getType(expr, expectedT);
	+ TypesHelper helper(pass->man->llvm);

	- case Operator::SWITCH:
	- {
	- return controlIR.compileSwitch(expr, DEFAULT("tmp_switch"));
	- }
	+ enum {RECORD, ARRAY} kind;
	+ if (helper.isArrayT(exprT)){
	+ kind = ARRAY;

	- case Operator::LOGIC_AND:
	- {
	- assert(expr.operands.size() == 1);
	- return process(expr.operands[0]);
	+ } else if (helper.isRecordT(exprT)){
	+ kind = RECORD;
	+ } else {
	+ assert(false && "Inapproriate type");
	}

	- case Operator::LIST: //init record or array
	- {
	- ExpandedType exprT = l.ast->getType(expr, expectedT);
	- TypesHelper helper(pass->man->llvm);
	+ #ifdef XREATE_ENABLE_EXTERN
	+ if (exprT->__operator == TypeOperator::ALIAS){
	+ if (l.layerExtern->isArrayType(exprT->__valueCustom)){
	+ flagIsArray = true;
	+ break;
	+ }

	- enum {RECORD, ARRAY} kind;
	- if (helper.isArrayT(exprT)){
	- kind = ARRAY;
	+ if (l.layerExtern->isRecordType(exprT->__valueCustom)){
	+ flagIsArray = false;
	+ break;
	+ }

	- } else if (helper.isRecordT(exprT)){
	- kind = RECORD;
	- } else {
	- assert(false && "Inapproriate type");
	+ assert(false && "Inapproriate external type");
	+ }
	+ #endif
	+
	+ switch(kind){
	+ case RECORD:{
	+ const std::vector<string> fieldsFormal = helper.getRecordFields(exprT);
	+ containers::RecordIR irRecords(ctx);
	+ llvm::StructType *recordTRaw = llvm::cast<llvm::StructType>(l.toLLVMType(exprT));
	+ llvm::Value *resultRaw = irRecords.init(recordTRaw);
	+ return irRecords.update(resultRaw, exprT, expr);
	}

	- #ifdef XREATE_ENABLE_EXTERN
	- if (exprT->__operator == TypeOperator::ALIAS){
	- if (l.layerExtern->isArrayType(exprT->__valueCustom)){
	- flagIsArray = true;
	- break;
	- }
	+ case ARRAY: {
	+ std::unique_ptr<containers::IContainersIR> containerIR(
	+ containers::IContainersIR::create(expr, expectedT, ctx));
	+ llvm::Value* aggrRaw = containerIR->init(hintAlias);
	+ return containerIR->update(aggrRaw, expr, hintAlias);
	+ }
	+ }
	+ break;
	+ };

	- if (l.layerExtern->isRecordType(exprT->__valueCustom)){
	- flagIsArray = false;
	- break;
	- }
	+ case Operator::LIST_RANGE:
	+ {
	+ assert(false); //no compilation phase for a range list
	+ // return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
	+ };

	- assert(false && "Inapproriate external type");
	- }
	- #endif
	-
	- switch(kind){
	- case RECORD:{
	- const std::vector<string> fieldsFormal = helper.getRecordFields(exprT);
	- containers::RecordIR irRecords(ctx);
	- llvm::StructType *recordTRaw = llvm::cast<llvm::StructType>(l.toLLVMType(exprT));
	- llvm::Value *resultRaw = irRecords.init(recordTRaw);
	- return irRecords.update(resultRaw, exprT, expr);
	- }
	+ case Operator::MAP:
	+ {
	+ assert(expr.blocks.size());

	- case ARRAY: {
	- std::unique_ptr<containers::IContainersIR> containerIR(
	- containers::IContainersIR::create(expr, expectedT, ctx));
	- llvm::Value* aggrRaw = containerIR->init(hintAlias);
	- return containerIR->update(aggrRaw, expr, hintAlias);
	- }
	+ containers::ImplementationType implType = containers::IContainersIR::getImplementation(expr, pass->man->root);
	+
	+ switch(implType){
	+ case containers::ImplementationType::SOLID: {
	+ ExpandedType exprT = pass->man->root->getType(expr, expectedT);
	+ ArrayHint hint = find(expr, ArrayHint{});
	+
	+ containers::ArrayIR compiler(exprT, hint, ctx);
	+ return compiler.operatorMap(expr, DEFAULT("map"));
	}
	- break;
	- };

	- case Operator::LIST_RANGE:
	- {
	- assert(false); //no compilation phase for a range list
	- // return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
	- };
	+ case containers::ImplementationType::ON_THE_FLY:{
	+ FlyHint hint = find<FlyHint>(expr, {});
	+ containers::FlyIR compiler(hint, ctx);

	- case Operator::MAP:
	- {
	- assert(expr.blocks.size());
	- return controlIR.compileMapSolidOutput(expr, DEFAULT("map"));
	- };
	+ return compiler.operatorMap(expr, DEFAULT("map"));
	+ }

	- case Operator::FOLD:
	+ default:
	+ break;
	+ }
	+ assert(false && "Operator MAP does not support this container impl");
	+ return nullptr;
	+ };
	+
	+ case Operator::FOLD:
	+ {
	+ return controlIR.compileFold(expr, DEFAULT("fold"));
	+ };
	+
	+ case Operator::FOLD_INF:
	+ {
	+ return controlIR.compileFoldInf(expr, DEFAULT("fold"));
	+ };
	+
	+ case Operator::INDEX:
	+ {
	+ assert(expr.operands.size() > 1);
	+
	+ const Expression& aggrE = expr.operands[0];
	+ const ExpandedType& aggrT = pass->man->root->getType(aggrE);
	+ llvm::Value* aggrRaw = process(aggrE);
	+ switch (aggrT->__operator) {
	+ case TypeOperator::RECORD:
	{
	- return controlIR.compileFold(expr, DEFAULT("fold"));
	- };
	+ list<string> fieldsList;
	+ for(auto opIt = ++expr.operands.begin(); opIt!=expr.operands.end(); ++opIt){
	+ fieldsList.push_back(getIndexStr(*opIt));
	+ }

	- case Operator::FOLD_INF:
	- {
	- return controlIR.compileFoldInf(expr, DEFAULT("fold"));
	+ return controlIR.compileStructIndex(aggrRaw, aggrT, fieldsList);
	};

	- case Operator::INDEX:
	+ case TypeOperator::ARRAY:
	{
	- assert(expr.operands.size() > 1);
	-
	- const Expression& aggrE = expr.operands[0];
	- const ExpandedType& aggrT = pass->man->root->getType(aggrE);
	- llvm::Value* aggrRaw = process(aggrE);
	- switch (aggrT->__operator) {
	- case TypeOperator::RECORD:
	- {
	- list<string> fieldsList;
	- for(auto opIt = ++expr.operands.begin(); opIt!=expr.operands.end(); ++opIt){
	- fieldsList.push_back(getIndexStr(*opIt));
	- }
	-
	- return controlIR.compileStructIndex(aggrRaw, aggrT, fieldsList);
	- };
	-
	- 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);
	- }
	- );
	-
	- std::unique_ptr<containers::IContainersIR> containersIR(
	- containers::IContainersIR::create(aggrE, expectedT, ctx)
	- );
	+ 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);
	+ }
	+ );

	- containers::ArrayIR* arraysIR = static_cast<containers::ArrayIR*>(containersIR.get());
	- return arraysIR->get(aggrRaw, indexes, hintAlias);
	- };
	+ std::unique_ptr<containers::IContainersIR> containersIR(
	+ containers::IContainersIR::create(aggrE, expectedT, ctx)
	+ );

	- default:
	- assert(false);
	- }
	+ containers::ArrayIR* arraysIR = static_cast<containers::ArrayIR*>(containersIR.get());
	+ return arraysIR->get(aggrRaw, indexes, hintAlias);
	};

	- case Operator::CALL_INTRINSIC:
	- {
	+ default:
	+ assert(false);
	+ }
	+ };
	+
	+ 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.irBuilder.CreateLoad(storage, hintAlias);
	// }

	- assert(false && "undefined intrinsic");
	- }
	+ assert(false && "undefined intrinsic");
	+ }

	- case Operator::QUERY:
	- case Operator::QUERY_LATE:
	- {
	- assert(false && "Should be processed by interpretation");
	- }
	+ case Operator::QUERY:
	+ case Operator::QUERY_LATE:
	+ {
	+ assert(false && "Should be processed by interpretation");
	+ }

	- case Operator::VARIANT:
	- {
	- const ExpandedType& typResult = pass->man->root->getType(expr);
	- llvm::Type* typResultRaw = l.toLLVMType(typResult);
	- llvm::Type* typIdRaw = llvm::cast<llvm::StructType>(typResultRaw)->getElementType(0);
	-
	- uint64_t id = expr.getValueDouble();
	- llvm::Value* resultRaw = llvm::UndefValue::get(typResultRaw);
	- resultRaw = l.irBuilder.CreateInsertValue(resultRaw, llvm::ConstantInt::get(typIdRaw, id), llvm::ArrayRef<unsigned>({0}));
	-
	- const ExpandedType& typVariant = ExpandedType(typResult->__operands.at(id));
	- llvm::Type* typVariantRaw = l.toLLVMType(typVariant);
	- llvm::Value* variantRaw = llvm::UndefValue::get(typVariantRaw);
	- assert(expr.operands.size() == typVariant->__operands.size() && "Wrong variant arguments count");
	- if (!typVariant->__operands.size()) return resultRaw;
	-
	- for (unsigned int fieldId = 0; fieldId < expr.operands.size(); ++fieldId) {
	- const ExpandedType& typField = ExpandedType(typVariant->__operands.at(fieldId));
	- Attachments::put<TypeInferred>(expr.operands.at(fieldId), typField);
	- llvm::Value* fieldRaw = process(expr.operands.at(fieldId));
	- assert(fieldRaw);
	-
	- variantRaw = l.irBuilder.CreateInsertValue(variantRaw, fieldRaw, llvm::ArrayRef<unsigned>({fieldId}));
	- }
	+ case Operator::VARIANT:
	+ {
	+ const ExpandedType& typResult = pass->man->root->getType(expr);
	+ llvm::Type* typResultRaw = l.toLLVMType(typResult);
	+ llvm::Type* typIdRaw = llvm::cast<llvm::StructType>(typResultRaw)->getElementType(0);

	- llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typResultRaw)->getElementType(1);
	- llvm::Value* addrAsStorage = l.irBuilder.CreateAlloca(typStorageRaw);
	- llvm::Value* addrAsVariant = l.irBuilder.CreateBitOrPointerCast(addrAsStorage, typVariantRaw->getPointerTo());
	+ uint64_t id = expr.getValueDouble();
	+ llvm::Value* resultRaw = llvm::UndefValue::get(typResultRaw);
	+ resultRaw = l.irBuilder.CreateInsertValue(resultRaw, llvm::ConstantInt::get(typIdRaw, id), llvm::ArrayRef<unsigned>({0}));

	- l.irBuilder.CreateStore(variantRaw, addrAsVariant);
	- llvm::Value* storageRaw = l.irBuilder.CreateLoad(typStorageRaw, addrAsStorage);
	- resultRaw = l.irBuilder.CreateInsertValue(resultRaw, storageRaw, llvm::ArrayRef<unsigned>({1}));
	+ const ExpandedType& typVariant = ExpandedType(typResult->__operands.at(id));
	+ llvm::Type* typVariantRaw = l.toLLVMType(typVariant);
	+ llvm::Value* variantRaw = llvm::UndefValue::get(typVariantRaw);
	+ assert(expr.operands.size() == typVariant->__operands.size() && "Wrong variant arguments count");
	+ if (!typVariant->__operands.size()) return resultRaw;

	- return resultRaw;
	- }
	+ for (unsigned int fieldId = 0; fieldId < expr.operands.size(); ++fieldId) {
	+ const ExpandedType& typField = ExpandedType(typVariant->__operands.at(fieldId));
	+ Attachments::put<TypeInferred>(expr.operands.at(fieldId), typField);
	+ llvm::Value* fieldRaw = process(expr.operands.at(fieldId));
	+ assert(fieldRaw);

	- case Operator::SWITCH_VARIANT:
	- {
	- return controlIR.compileSwitchVariant(expr, DEFAULT("tmpswitch"));
	+ variantRaw = l.irBuilder.CreateInsertValue(variantRaw, fieldRaw, llvm::ArrayRef<unsigned>({fieldId}));
	}

	- case Operator::SWITCH_LATE:
	- {
	- assert(false && "Instruction's compilation should've been redirected to interpretation");
	- return nullptr;
	- }
	+ llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typResultRaw)->getElementType(1);
	+ llvm::Value* addrAsStorage = l.irBuilder.CreateAlloca(typStorageRaw);
	+ llvm::Value* addrAsVariant = l.irBuilder.CreateBitOrPointerCast(addrAsStorage, typVariantRaw->getPointerTo());

	- case Operator::SEQUENCE:
	- {
	- return controlIR.compileSequence(expr);
	- }
	+ l.irBuilder.CreateStore(variantRaw, addrAsVariant);
	+ llvm::Value* storageRaw = l.irBuilder.CreateLoad(typStorageRaw, addrAsStorage);
	+ resultRaw = l.irBuilder.CreateInsertValue(resultRaw, storageRaw, llvm::ArrayRef<unsigned>({1}));

	- case Operator::UNDEF:
	- {
	- llvm::Type* typExprUndef = l.toLLVMType(pass->man->root->getType(expr, expectedT));
	- return llvm::UndefValue::get(typExprUndef);
	- }
	+ return resultRaw;
	+ }

	- case Operator::UPDATE:
	- {
	- TypesHelper helper(pass->man->llvm);
	- containers::RecordIR irRecords(ctx);
	+ case Operator::SWITCH_VARIANT:
	+ {
	+ return controlIR.compileSwitchVariant(expr, DEFAULT("tmpswitch"));
	+ }

	- const Expression& aggrE = expr.operands.at(0);
	- const Expression& updE = expr.operands.at(1);
	- const ExpandedType& aggrT = pass->man->root->getType(aggrE);
	- llvm::Value* aggrRaw = process(aggrE);
	+ case Operator::SWITCH_LATE:
	+ {
	+ assert(false && "Instruction's compilation should've been redirected to interpretation");
	+ return nullptr;
	+ }

	- if (helper.isRecordT(aggrT)){
	- return irRecords.update(aggrRaw, aggrT, updE);
	- }
	+ case Operator::SEQUENCE:
	+ {
	+ return controlIR.compileSequence(expr);
	+ }

	- if (helper.isArrayT(aggrT)){
	- if (updE.op == Operator::LIST_INDEX){
	+ case Operator::UNDEF:
	+ {
	+ llvm::Type* typExprUndef = l.toLLVMType(pass->man->root->getType(expr, expectedT));
	+ return llvm::UndefValue::get(typExprUndef);
	+ }

	- std::unique_ptr<containers::IContainersIR> containersIR(
	- containers::IContainersIR::create(aggrE, TypeAnnotation(), ctx
	- ));
	+ case Operator::UPDATE:
	+ {
	+ TypesHelper helper(pass->man->llvm);
	+ containers::RecordIR irRecords(ctx);

	- return containersIR->update(aggrRaw, updE, hintAlias);
	- }
	- }
	+ const Expression& aggrE = expr.operands.at(0);
	+ const Expression& updE = expr.operands.at(1);
	+ const ExpandedType& aggrT = pass->man->root->getType(aggrE);
	+ llvm::Value* aggrRaw = process(aggrE);

	- assert(false);
	- return nullptr;
	+ if (helper.isRecordT(aggrT)){
	+ return irRecords.update(aggrRaw, aggrT, updE);
	}

	- case Operator::INVALID:
	- assert(expr.__state != Expression::COMPOUND);
	+ if (helper.isArrayT(aggrT)){
	+ if (updE.op == Operator::LIST_INDEX){

	- switch (expr.__state) {
	- case Expression::IDENT:
	- {
	- Symbol s = Attachments::get<IdentifierSymbol>(expr);
	- return processSymbol(s, expr.getValueString());
	- }
	+ std::unique_ptr<containers::IContainersIR> containersIR(
	+ containers::IContainersIR::create(aggrE, TypeAnnotation(), ctx
	+ ));

	- case Expression::NUMBER:
	- {
	- llvm::Type* typConst = l.toLLVMType(pass->man->root->getType(expr, expectedT));
	- int literal = expr.getValueDouble();
	+ return containersIR->update(aggrRaw, updE, hintAlias);
	+ }
	+ }

	- if (typConst->isFloatingPointTy()) return llvm::ConstantFP::get(typConst, literal);
	- if (typConst->isIntegerTy()) return llvm::ConstantInt::get(typConst, literal);
	-
	- assert(false && "Can't compile literal");
	- }
	+ assert(false);
	+ return nullptr;
	+ }

	- case Expression::STRING:
	- {
	- return controlIR.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
	- };
	+ case Operator::INVALID:
	+ assert(expr.__state != Expression::COMPOUND);

	- default:
	- {
	- break;
	- }
	- };
	+ switch (expr.__state) {
	+ case Expression::IDENT:
	+ {
	+ Symbol s = Attachments::get<IdentifierSymbol>(expr);
	+ return processSymbol(s, expr.getValueString());
	+ }

	- break;
	+ case Expression::NUMBER:
	+ {
	+ llvm::Type* typConst = l.toLLVMType(pass->man->root->getType(expr, expectedT));
	+ int literal = expr.getValueDouble();
	+
	+ if (typConst->isFloatingPointTy()) return llvm::ConstantFP::get(typConst, literal);
	+ if (typConst->isIntegerTy()) return llvm::ConstantInt::get(typConst, literal);
	+
	+ assert(false && "Can't compile literal");
	+ }

	- default: break;
	+ case Expression::STRING:
	+ {
	+ return controlIR.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
	+ };

	+ default:
	+ {
	+ break;
	}
	+ };
	+
	+ break;
	+
	+ default: break;
	+
	+ }

	- assert(false && "Can't compile expression");
	- return 0;
	+ assert(false && "Can't compile expression");
	+ return 0;
	}

	llvm::Value*
	BasicBruteScope::compile(const std::string& hintBlockDecl) {
	- LLVMLayer* llvm = pass->man->llvm;
	+ LLVMLayer* llvm = pass->man->llvm;

	- if (!hintBlockDecl.empty()) {
	- llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm->llvmContext, hintBlockDecl, function->raw);
	- pass->man->llvm->irBuilder.SetInsertPoint(block);
	- }
	+ if (!hintBlockDecl.empty()) {
	+ llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm->llvmContext, hintBlockDecl, function->raw);
	+ pass->man->llvm->irBuilder.SetInsertPoint(block);
	+ }

	- currentBlockRaw = pass->man->llvm->irBuilder.GetInsertBlock();
	- Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
	- return processSymbol(symbScope);
	+ lastBlockRaw = pass->man->llvm->irBuilder.GetInsertBlock();
	+ Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
	+ return processSymbol(symbScope);
	}

	IBruteScope::~IBruteScope() { }

	IBruteFunction::~IBruteFunction() { }

	llvm::Function*
	IBruteFunction::compile() {
	if (raw != nullptr) return raw;

	LLVMLayer* llvm = pass->man->llvm;
	llvm::IRBuilder<>& builder = llvm->irBuilder;

	string&& functionName = prepareName();
	std::vector<llvm::Type*>&& types = prepareSignature();
	llvm::Type* expectedResultType = prepareResult();

	llvm::FunctionType *ft = llvm::FunctionType::get(expectedResultType, types, false);
	raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(functionName, ft));
	prepareBindings();
	+ applyAttributes();

	- const std::string&blockName = "entry";
	+ const std::string& blockName = "entry";
	llvm::BasicBlock* blockCurrent = builder.GetInsertBlock();

	- llvm::Value* result = getScopeUnit(function->__entry)->compile(blockName);
	+ llvm::Value* result = getScopeUnit(__entry)->compile(blockName);
	assert(result);

	//SECTIONTAG types/convert function ret value
	builder.CreateRet(typeinference::doAutomaticTypeConversion(result, expectedResultType, llvm->irBuilder));

	if (blockCurrent) {
	builder.SetInsertPoint(blockCurrent);
	}

	llvm->moveToGarbage(ft);
	return raw;
	}

	IBruteScope*
	IBruteFunction::getScopeUnit(const CodeScope * const scope) {
	if (__scopes.count(scope)) {
	auto result = __scopes.at(scope).lock();

	if (result) {
	return result.get();
	}
	}

	std::shared_ptr<IBruteScope> 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();
	}

	IBruteScope*
	IBruteFunction::getScopeUnit(ManagedScpPtr scope) {
	return getScopeUnit(&*scope);
	}

	IBruteScope*
	IBruteFunction::getEntry() {
	- return getScopeUnit(function->getEntryScope());
	+ return getScopeUnit(__entry);
	+}
	+
	+std::vector<llvm::Type*>
	+IBruteFunction::getScopeSignature(CodeScope* scope){
	+ LLVMLayer* llvm = IBruteFunction::pass->man->llvm;
	+ AST* ast = IBruteFunction::pass->man->root;
	+ std::vector<llvm::Type*> result;
	+
	+ std::transform(scope->__bindings.begin(), scope->__bindings.end(), std::inserter(result, result.end()),
	+ [llvm, ast, scope](const std::string & arg)->llvm::Type* {
	+ assert(scope->__identifiers.count(arg));
	+
	+ ScopedSymbol argid{scope->__identifiers.at(arg), versions::VERSION_NONE};
	+ return llvm->toLLVMType(ast->expandType(scope->__declarations.at(argid).type));
	+ });
	+
	+ return result;
	}

	template<>
	compilation::IBruteFunction*
	CompilePassCustomDecorators<void, void>
	::buildFunctionUnit(const ManagedFnPtr& function) {
	return new BruteFunctionDefault(function, this);
	+
	}

	template<>
	compilation::IBruteScope*
	CompilePassCustomDecorators<void, void>
	::buildCodeScopeUnit(const CodeScope * const scope, IBruteFunction* function) {
	return new DefaultCodeScopeUnit(scope, function, this);
	}

	std::string
	BasicBruteScope::getIndexStr(const Expression& index){
	switch(index.__state){

	//named struct field
	case Expression::STRING:
	return index.getValueString();
	break;

	//anonymous struct field
	case Expression::NUMBER:
	return to_string((int) index.getValueDouble());
	break;

	default:
	assert(false && "Wrong index for a struct");
	}
	return "";
	}

	} // end of compilation

	compilation::IBruteFunction*
	CompilePass::getFunctionUnit(const ManagedFnPtr& function) {
	unsigned int id = function.id();

	if (!functions.count(id)) {
	compilation::IBruteFunction* unit = buildFunctionUnit(function);
	functions.emplace(id, unit);
	return unit;
	}

	return functions.at(id);
	}

	void
	CompilePass::prepare(){
	//Initialization:
	#ifndef XREATE_CONFIG_MIN
	#endif
	managerTransformations = new xreate::compilation::TransformationsManager();
	targetInterpretation = new interpretation::TargetInterpretation(man, this);
	}

	void
	CompilePass::run() {
	prepare();

	//Determine entry function:
	StaticModel model = man->transcend->query(analysis::FN_ENTRY_PREDICATE);
	assert(model.size() && "Error: No entry function found");
	assert(model.size() == 1 && "Error: Ambiguous entry function");

	string nameMain = std::get<0>(TranscendLayer::parse<std::string>(model.begin()->second));
	compilation::IBruteFunction* unitMain = getFunctionUnit(man->root->findFunction(nameMain));

	//Compilation itself:
	entry = unitMain->compile();
	}

	llvm::Function*
	CompilePass::getEntryFunction() {
	assert(entry);
	return entry;
	}

	void
	CompilePass::prepareQueries(TranscendLayer* transcend) {
	#ifndef XREATE_CONFIG_MIN
	transcend->registerQuery(new latex::LatexQuery(), QueryId::LatexQuery);
	#endif

	transcend->registerQuery(new containers::Query(), QueryId::ContainersQuery);
	transcend->registerQuery(new demand::DemandQuery(), QueryId::DemandQuery);
	transcend->registerQuery(new polymorph::PolymorphQuery(), QueryId::PolymorphQuery);
	}

	} //end of namespace xreate

	/**
	* \class xreate::CompilePass
	* \brief The owner of the compilation process. Performs fundamental compilation activities along with the xreate::compilation's routines
	*
	* xreate::CompilePass traverses over xreate::AST tree and produces executable code.
	* The pass performs compilation using the following data sources:
	* - %Attachments: the data gathered by the previous passes. See \ref xreate::Attachments.
	* - Transcend solutions accessible via queries. See \ref xreate::IQuery, \ref xreate::TranscendLayer.
	*
	* The pass generates a bytecode by employing \ref xreate::LLVMLayer(wrapper over LLVM toolchain).
	* Many compilation activities are delegated to more specific routines. Most notable delegated compilation aspects are:
	* - Containers support. See \ref xreate::containers.
	* - Latex compilation. See \ref xreate::latex.
	* - Interpretation support. See \ref xreate::interpretation.
	* - Loop saturation support. See \ref xreate::compilation::TransformationsScopeDecorator.
	* - External code interaction support. See \ref xreate::ExternLayer (wrapper over Clang library).
	*
	* \section adaptability_sect Adaptability
	* xreate::CompilePass's behaviour can be adapted in several ways:
	* - %Function Decorators to alter function-level compilation. See \ref xreate::compilation::IBruteFunction
	* - Code Block Decorators to alter code block level compilation. See \ref xreate::compilation::ICodeScopeUnit.
	* Default functionality defined by \ref xreate::compilation::DefaultCodeScopeUnit
	* - Targets to allow more versitile extensions.
	* Currently only xreate::interpretation::TargetInterpretation use Targets infrastructure. See \ref xreate::compilation::Target.
	* - Altering %function invocation. See \ref xreate::compilation::IFnInvocation.
	*
	* Clients are free to construct a compiler instantiation with the desired decorators by using \ref xreate::compilation::CompilePassCustomDecorators.
	* As a handy alias, `CompilePassCustomDecorators<void, void>` constructs the default compiler.
	*
	*/
	diff --git a/cpp/src/pass/compilepass.h b/cpp/src/pass/compilepass.h
	index bc503c1..3e3d247 100644
	--- a/cpp/src/pass/compilepass.h
	+++ b/cpp/src/pass/compilepass.h
	@@ -1,225 +1,233 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* compilepass.h
	*/

	#ifndef COMPILEPASS_H
	#define COMPILEPASS_H

	#include "abstractpass.h"
	-
	#include "llvm/IR/Function.h"

	namespace xreate {
	class TranscendLayer;
	class CompilePass;
	class LLVMLayer;

	namespace interpretation{
	class TargetInterpretation;
	}
	}

	namespace xreate { namespace compilation {

	class IBruteScope;
	class IBruteFunction;
	class TransformationsManager;

	/** \brief Holds current position in %AST while traversing*/
	struct Context{
	IBruteScope* scope;
	IBruteFunction* function;
	CompilePass* pass;
	};

	/** \brief Interface for custom function invocation operation compilation
	* \details Default implementation is xreate::compilation::BruteFnInvocation
	*/
	class IFnInvocation {
	public:
	/** \brief Returns result of custom function invocation for the given arguments*/
	virtual llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl="") = 0;
	};

	/** \brief Default IFnInvocation implementation */
	class BruteFnInvocation: public IFnInvocation{
	public:
	BruteFnInvocation(llvm::Function* callee, LLVMLayer* l)
	: __callee(callee), __calleeTy(callee->getFunctionType()), llvm(l) {}
	BruteFnInvocation(llvm::Value* callee, llvm::FunctionType* ty, LLVMLayer* l)
	: __callee(callee), __calleeTy(ty), llvm(l) {}

	/** \brief Makes type conversions and returns LLVM call statement with given arguments*/
	llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl="");

	protected:
	llvm::Value* __callee;
	llvm::FunctionType* __calleeTy;
	LLVMLayer* llvm;
	};

	/** \brief %Function invocation operator decorator to handle latex enabled functions with hidden extra arguments */
	class HiddenArgsFnInvocation : public compilation::IFnInvocation{
	public:
	HiddenArgsFnInvocation(std::vector<llvm::Value > args, compilation::IFnInvocation parent)
	: __args(args), __parent(parent){}

	llvm::Value operator()(std::vector<llvm::Value > &&args, const std::string &hintDecl = "");

	private:
	std::vector<llvm::Value *> __args;
	compilation::IFnInvocation *__parent;
	};

	/** \brief Interface to allow modification of CodeScope compilation
	* \details Default implementation defined in xreate::compilation::DefaultCodeScopeUnit
	*/
	class IBruteScope{
	public:
	CompilePass* const pass;
	IBruteFunction* const function;
	const CodeScope* const scope;
	- llvm::BasicBlock* currentBlockRaw;
	+ llvm::BasicBlock* lastBlockRaw;

	IBruteScope(const CodeScope* const codeScope, IBruteFunction* f, CompilePass* compilePass);
	virtual ~IBruteScope();

	virtual llvm::Value* compile(const std::string& hintBlockDecl="")=0;
	virtual llvm::Value* processSymbol(const Symbol& s, std::string hintRetVar="")=0;
	virtual llvm::Value* process(const Expression& expr, const std::string& hintVarDecl="", const TypeAnnotation& expectedT = TypeAnnotation())=0;

	virtual Symbol bindArg(llvm::Value* value, std::string&& alias)=0;
	virtual void bindArg(llvm::Value* value, const ScopedSymbol& s)=0;
	virtual void reset() = 0;

	protected:
	/** \brief For subclasses to implement this method to define a function name resolution*/
	virtual IFnInvocation* findFunction(const Expression& opCall)=0;
	};

	/** \brief Minimal useful IBruteScope implementation suited for inheritance */
	class BasicBruteScope: public IBruteScope{
	public:
	BasicBruteScope(const CodeScope* const codeScope, IBruteFunction* f, CompilePass* compilePass);

	llvm::Value* processSymbol(const Symbol& s, std::string hintRetVar="") override;
	llvm::Value* process(const Expression& expr, const std::string& hintAlias="", const TypeAnnotation& expectedT = TypeAnnotation()) override;
	llvm::Value* compile(const std::string& hintBlockDecl="") override;

	protected:
	IFnInvocation* findFunction(const Expression& opCall) override;

	private:
	std::string getIndexStr(const Expression& index);
	};

	/** \brief Interface to specify compilation of %Function */
	class IBruteFunction{
	public:
	- IBruteFunction(ManagedFnPtr f, CompilePass* p): function(f), pass(p) {}
	+ IBruteFunction(CodeScope* entry, CompilePass* p): pass(p), __entry(entry){}
	virtual ~IBruteFunction();

	llvm::Function* compile();

	IBruteScope* getEntry();
	+ virtual ManagedFnPtr getASTFn() const {return ManagedFnPtr();};
	IBruteScope* getScopeUnit(const CodeScope * const scope);
	IBruteScope* getScopeUnit(ManagedScpPtr scope);

	- virtual llvm::Type* prepareResult() = 0;
	-
	- ManagedFnPtr function;
	llvm::Function* raw = nullptr;

	protected:
	CompilePass* pass=nullptr;
	+ CodeScope* __entry;

	virtual std::string prepareName() = 0;
	virtual std::vector<llvm::Type*> prepareSignature() = 0;
	virtual llvm::Function::arg_iterator prepareBindings() = 0;
	-
	+ virtual llvm::Type* prepareResult() = 0;
	+ virtual void applyAttributes() = 0;
	+
	private:
	std::map<const CodeScope * const, std::weak_ptr<IBruteScope>> __scopes;
	std::list<std::shared_ptr<IBruteScope>> __orphanedScopes;
	+
	+protected:
	+ std::vector<llvm::Type> getScopeSignature(CodeScope scope);
	};

	/** \brief Minimal useful IBruteFunction implementation suited for inheritance */
	class BasicBruteFunction: public IBruteFunction{
	public:
	BasicBruteFunction(ManagedFnPtr f, CompilePass* p)
	- : IBruteFunction(f, p) {}
	+ : IBruteFunction(f->getEntryScope(), p), __function(f) {}

	protected:
	std::string prepareName() override;
	virtual std::vector<llvm::Type*> prepareSignature() override;
	virtual llvm::Type* prepareResult() override;
	virtual llvm::Function::arg_iterator prepareBindings() override;
	+ virtual void applyAttributes() override;
	+ virtual ManagedFnPtr getASTFn() const {return __function;};
	+
	+protected:
	+ ManagedFnPtr __function;
	};
	} // end of namespace compilation

	class CompilePass : public AbstractPass<void> {
	friend class compilation::BasicBruteScope;
	friend class compilation::IBruteFunction;

	public:
	compilation::TransformationsManager* managerTransformations;
	interpretation::TargetInterpretation* targetInterpretation;

	CompilePass(PassManager* manager): AbstractPass<void>(manager) {}
	/** \brief Executes compilation process */
	void run() override;

	/**\brief Returns compiled specified %Function
	* \details Executes function compilation or read cache if it's already done
	*/
	compilation::IBruteFunction* getFunctionUnit(const ManagedFnPtr& function);

	/*\brief Returns compiled main(entry) %Function in program /
	llvm::Function* getEntryFunction();

	/** \brief Initializes queries required by compiler. See xreate::IQuery, xreate::TranscendLayer */
	static void prepareQueries(TranscendLayer* transcend);
	void prepare();

	protected:
	virtual compilation::IBruteFunction* buildFunctionUnit(const ManagedFnPtr& function)=0;
	virtual compilation::IBruteScope* buildCodeScopeUnit(const CodeScope* const scope, compilation::IBruteFunction* function)=0;

	private:
	//TODO free `functions` in destructor
	std::map<unsigned int, compilation::IBruteFunction*> functions;
	llvm::Function* entry = 0;
	};

	namespace compilation{

	/** \brief Constructs compiler with desired %Function and %Code Scope decorators. See adaptability in xreate::CompilePass*/
	template<class FUNCTION_DECORATOR=void, class SCOPE_DECORATOR=void>
	class CompilePassCustomDecorators: public ::xreate::CompilePass{
	public:
	CompilePassCustomDecorators(PassManager* manager): ::xreate::CompilePass(manager) {}

	virtual compilation::IBruteFunction* buildFunctionUnit(const ManagedFnPtr& function) override{
	return new FUNCTION_DECORATOR(function, this);
	}

	virtual compilation::IBruteScope* buildCodeScopeUnit(const CodeScope* const scope, IBruteFunction* function) override{
	return new SCOPE_DECORATOR(scope, function, this);
	}
	};

	template<>
	compilation::IBruteFunction*
	CompilePassCustomDecorators<void, void>::buildFunctionUnit(const ManagedFnPtr& function);

	template<>
	compilation::IBruteScope*
	CompilePassCustomDecorators<void, void>::buildCodeScopeUnit(const CodeScope* const scope, IBruteFunction* function);

	}} //end of namespace xreate::compilation

	#endif // COMPILEPASS_H
	diff --git a/cpp/src/utils.h b/cpp/src/utils.h
	index cd4ae1a..beb5d8d 100644
	--- a/cpp/src/utils.h
	+++ b/cpp/src/utils.h
	@@ -1,160 +1,156 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* utils.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#ifndef UTILS_H
	#define UTILS_H

	#include <vector>
	#include <string>

	namespace xreate {

	template<class Tag, class Source>
	struct AddTag {

	explicit
	AddTag(const Source &src)
	: __src(src) { }

	explicit
	AddTag(Source &&src)
	: __src(std::move(src)) { }

	- operator const Source&() const{
	- return __src;
	- }
	-
	const Source& get() const{
	return __src;
	}

	const Source*
	operator->() const {
	return &__src;
	}

	private:
	Source __src;
	};

	struct Expand_t{};
	template<class Source>
	using Expanded = AddTag<Expand_t, Source>;

	/** \brief Decorators support */
	template<class DecoratorTag>
	struct DecoratorsDict{
	//typedef ConcreteDecoratorForTag result;
	};

	template<class DecoratorTag>
	struct Decorators{
	typedef typename DecoratorsDict<DecoratorTag>::result Instance;

	template<class Base>
	static Instance* getInterface(Base* obj){
	Instance* result = dynamic_cast< Instance* > (obj);
	assert(result);

	return result;
	}
	};

	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;
	}

	bool operator< (const ManagedPtr<Target>& other) const{
	if(__storage != other.__storage) return __storage < other.__storage;
	return __id < other.__id;
	}

	private:
	unsigned int __id = 0;
	const std::vector<Target> __storage = 0;
	};

	}

	std::wstring
	utf8_to_wstring(const std::string& str);

	std::string
	wstring_to_utf8(const std::wstring& str);


	#define RST "\x1B[0m"
	#define KRED "\x1B[31m"
	#define KGRN "\x1B[32m"
	#define KYEL "\x1B[33m"
	#define KBLU "\x1B[34m"
	#define KMAG "\x1B[35m"
	#define KCYN "\x1B[36m"
	#define KWHT "\x1B[37m"

	#define FRED(x) KRED << x << RST
	#define FGRN(x) KGRN <<x << RST
	#define FYEL(x) KYEL << x << RST
	#define FBLU(x) KBLU << x << RST
	#define FMAG(x) KMAG x RST
	#define FCYN(x) KCYN x RST
	#define FWHT(x) KWHT x RST

	#define BOLD(x) "\x1B[1m" x RST
	#define UNDL(x) "\x1B[4m" x RST

	#endif // UTILS_H
	diff --git a/cpp/tests/compilation.cpp b/cpp/tests/compilation.cpp
	index d44f2cf..367e8de 100644
	--- a/cpp/tests/compilation.cpp
	+++ b/cpp/tests/compilation.cpp
	@@ -1,278 +1,304 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* compilation.cpp
	*
	* Created on: -
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "xreatemanager.h"
	#include "supplemental/basics.h"
	#include "llvmlayer.h"
	+#include "pass/compilepass.h"
	+#include "compilation/lambdas.h"

	#include "gtest/gtest.h"

	using namespace xreate;
	+using namespace xreate::compilation;
	using namespace std;
	//DEBT implement no pkgconfig ways to link libs
	//TOTEST FunctionUnit::compileInline

	TEST(Compilation, functionEntry1){
	std::unique_ptr<XreateManager> program(XreateManager::prepare(
	"func1 = function(a:: int):: int {a+8} \
	func2 = function::int; entry {12 + func1(4)} \
	"));

	void* entryPtr = program->run();
	int (entry)() = (int ()())(intptr_t)entryPtr;

	int answer = entry();
	ASSERT_EQ(24, answer);
	}

	TEST(Compilation, full_IFStatementWithVariantType){
	XreateManager* man = XreateManager::prepare(
	"Color = type variant {RED, BLUE, GREEN}.\n"
	"\n"
	" main = function(x::int):: bool; entry {\n"
	" color = if (x == 0 )::Color {RED()} else {BLUE()}.\n"
	" if (color == BLUE())::bool {true} else {false}\n"
	" }"
	);

	bool (main)(int) = (bool ()(int)) man->run();
	ASSERT_FALSE(main(0));
	ASSERT_TRUE(main(1));
	}

	TEST(Compilation, full_Variant1){
	XreateManager* man = XreateManager::prepare(R"Code(
	global = type predicate {
	entry
	}

	Command= type variant{
	Add(x::int, y::int),
	Dec(x::int)
	}.

	main = function::Command; entry() {
	Dec(2) ::Command
	}
	)Code");

	void (main)() = (void ()()) man->run();
	}

	TEST(Compilation, full_SwitchVariant1){
	XreateManager* man = XreateManager::prepare(R"Code(
	Command= type variant{
	Add(x::int, y::int),
	Dec(x::int)
	}.

	main = function::int; entry {
	command = Add(3, 5):: Command.

	switch variant(command)::int
	case(Add){command["x"] + command["y"]}
	case(Dec){command["x"]}
	}
	)Code");

	int (mainFn)() = (int ()()) man->run();
	int result = mainFn();
	ASSERT_EQ(8, result);
	}

	TEST(Compilation, full_SwitchVariantNoArguments2){
	XreateManager* man = XreateManager::prepare(R"Code(
	Command= type variant{Add, Dec}.

	main = function::int; entry {
	command = Dec():: Command.

	switch variant(command)::int
	case(Add){0}
	case(Dec){1}
	}
	)Code");

	int (mainFn)() = (int ()()) man->run();
	int result = mainFn();
	ASSERT_EQ(1, result);
	}

	TEST(Compilation, full_SwitchVariantMixedArguments3){
	XreateManager* man = XreateManager::prepare(R"Code(
	Command= type variant{
	Add(x::int, y::int),
	Dec
	}.

	main = function(arg::int):: int; entry {
	command = if (arg > 0)::Command {Dec()} else {Add(1, 2)}.

	switch variant(command)::int
	case(Add){0}
	case(Dec){1}
	}
	)Code");

	int (mainFn)(int) = (int ()(int)) man->run();
	int result = mainFn(5);
	ASSERT_EQ(1, result);
	}

	TEST(Compilation, full_StructUpdate){
	XreateManager* man = XreateManager::prepare(
	R"Code(

	Rec = type {
	a :: int,
	b:: int
	}.

	test= function:: int; entry {
	a = {a = 18, b = 20}:: Rec.

	b = a + {a = 11}:: Rec.
	b["a"]
	}
	)Code");

	int (main)() = (int ()()) man->run();
	int result = main();

	ASSERT_EQ(11, result);
	}

	TEST(Compilation, AnonymousStruct_init_index){
	std::string code =
	R"Code(

	main = function:: int; entry {
	x = {10, 15} :: {int, int}.
	x[1]
	}

	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (main)() = (int ()()) man->run();

	EXPECT_EQ(15, main());
	}

	TEST(Compilation, AnonymousStruct_init_update){
	std::string code =
	R"Code(

	main = function:: int; entry {
	x = {10, 15} :: {int, int}.
	y = x + {6}:: {int, int}.
	y[0]
	}

	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (main)() = (int ()()) man->run();

	EXPECT_EQ(6, main());
	}

	TEST(Compilation, BugIncorrectScopes1){
	std::string code =
	R"Code(

	init = function:: int {10}
	main = function(cmd:: int):: int; entry {
	x = init():: int.
	if(cmd > 0):: int { x + 1 } else { x }
	}
	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (mainFn)(int) = (int ()(int)) man->run();

	EXPECT_EQ(11, mainFn(1));
	}

	TEST(Compilation, Sequence1){
	std::string code =
	R"Code(
	interface(extern-c){
	libbsd = library:: pkgconfig("libbsd").

	include {
	libbsd = {"bsd/stdlib.h", "string.h"}
	}.
	}

	start = function:: i32; entry {
	seq {
	nameNew = "TestingSequence":: string.
	setprogname(nameNew)

	} {strlen(getprogname())}::i32
	}
	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (startFn)() = (int ()()) man->run();

	int nameNewLen = startFn();
	ASSERT_EQ(15, nameNewLen);
	}

	TEST(Compilation, BoolInstructions1){
	std::string code =
	R"Code(
	test = function (a:: bool, b:: bool):: bool; entry
	{
	-a
	}
	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	Fn2Args startFn = (Fn2Args) man->run();
	}

	TEST(Compilation, StructIndex1){
	std::string code =
	R"Code(
	Anns = type predicate {
	entry()
	}
	test = function:: int; entry()
	{
	x = {a = ({b = 3}::{b:: int})}:: {a:: {b:: int}}.
	2 + x["a", "b"] + x["a"]["b"]
	}
	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	FnNoArgs startFn = (FnNoArgs) man->run();
	int result = startFn();
	ASSERT_EQ(2, result);
	}

	TEST(Compilation, PreferredInt1){
	std::unique_ptr<XreateManager> man(XreateManager::prepare(""));
	TypesHelper utils(man->llvm);
	int bitwidth = utils.getPreferredIntTy()->getBitWidth();
	ASSERT_EQ(64, bitwidth);
	}

	TEST(Compilation, PredPredicates1){
	string code = R"(
	my-fn = function:: int; entry() {0}
	)";

	auto man = XreateManager::prepare(move(code));
	FnNoArgs startFn = (FnNoArgs) man->run();
	int result = startFn();
	ASSERT_EQ(0, result);
	+}
	+
	+typedef intmax_t (*FnI_I)(intmax_t);
	+TEST(Compilation, Lambda1){
	+ string code = R"(
	+myfn = function:: int {
	+ a = [1..5]:: [int].
	+ loop map(a->x:: int):: [int] { x + 10:: int}
	+}
	+)";
	+ auto man = details::tier1::XreateManager::prepare(move(code));
	+ LLVMLayer* llvm = man->llvm;
	+ man->analyse();
	+
	+ std::unique_ptr<CompilePass> compiler(new compilation::CompilePassCustomDecorators<>(man));
	+ compiler->prepare();
	+ LambdaIR compilerLambda(compiler.get());
	+ CodeScope* scopeLoop = man->root->findFunction("myfn")->getEntryScope()->getBody().blocks.front();
	+ auto fnRaw = compilerLambda.compile(scopeLoop, "loop");
	+ llvm->initJit();
	+
	+ FnI_I fn = (FnI_I)llvm->getFunctionPointer(fnRaw);
	+ ASSERT_EQ(20, fn(10));
	}
	\ No newline at end of file
	diff --git a/cpp/tests/containers.cpp b/cpp/tests/containers.cpp
	index a7123c0..8f3074a 100644
	--- a/cpp/tests/containers.cpp
	+++ b/cpp/tests/containers.cpp
	@@ -1,299 +1,321 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* containers.cpp
	*
	* Created on: Jun 9, 2015
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "xreatemanager.h"
	#include "query/containers.h"
	#include "main/Parser.h"

	#include "supplemental/docutils.h"
	#include "supplemental/basics.h"
	#include "gtest/gtest.h"

	using namespace std;
	using namespace xreate::grammar::main;
	using namespace xreate::containers;
	using namespace xreate;

	-TEST(Containers, AST_List1){
	- string code = R"(
	- my-test = function:: int {
	- {month = 1, 2, #3 = 8}
	- }
	- )";
	-
	- auto man = XreateManager::prepare(move(code));
	- const Expression& listE = man->root->findFunction("my-test")->getEntryScope()->getBody();
	- ASSERT_EQ(3, listE.bindings.size());
	- ASSERT_EQ(3, listE.operands.size());
	- set<string> fields;
	- fields.insert(listE.bindings.begin(), listE.bindings.end());
	-
	- ASSERT_TRUE(fields.count("month"));
	- ASSERT_TRUE(fields.count("0"));
	- ASSERT_TRUE(fields.count("3"));
	-}
	+struct Tuple2 {intmax_t a; intmax_t b;};
	+typedef Tuple2 (*FnTuple2)();

	-TEST(AST, AST_ListIndex1){
	- string code = R"(
	- my-fn = function:: int; entry()
	- {
	- x = [1..2]:: [int].
	- x + {[1] = 1}
	- }
	- )";
	+struct Tuple3 {intmax_t a; intmax_t b; intmax_t c; };
	+typedef Tuple3 (*FnTuple3)();

	- auto man = XreateManager::prepare(move(code));
	- const Expression& bodyE = man->root->findFunction("my-fn")->getEntryScope()->getBody();
	+struct Tuple4 {intmax_t a; intmax_t b; intmax_t c; intmax_t d;};
	+typedef Tuple4 (*FnTuple4)();

	- ASSERT_EQ(2, bodyE.operands.size());
	- const Expression opLiInE = bodyE.operands.at(1);
	- ASSERT_EQ(2, opLiInE.operands.size());
	-}
	-
	-TEST(Containers, DONE_RecInitByList1){
	+TEST(Containers, RecInitByList1){
	string code = R"(
	Rec = type {x:: int, y:: int}.
	test = function(a:: int, b::int):: Rec; entry() {
	{x = a + b, y = 2}
	}
	)";

	auto man = XreateManager::prepare(move(code));
	man->run();
	}

	-TEST(Containers, DONE_RecInitByList2){
	+TEST(Containers, RecInitByList2){
	string code = R"(
	Rec = type {x:: int, y:: int}.
	test = function(a:: int, b::int):: Rec; entry() {
	- {a + b, y = 2}
	+ {a + b, y = 2}
	}
	)";

	auto man = XreateManager::prepare(move(code));
	man->run();
	}

	-TEST(Containers, DONE_RecUpdateByList1){
	+TEST(Containers, RecUpdateByList1){
	string code = R"(
	Rec = type {x:: int, y:: int}.
	test = function(a:: int, b::int):: Rec; entry() {
	r = {0, y = 2}:: Rec.

	r : {a + b}
	}
	)";

	auto man = XreateManager::prepare(move(code));
	man->run();
	}

	-TEST(Containers, DONE_RecUpdateByListIndex1){
	+TEST(Containers, RecUpdateByListIndex1){
	string code = R"(
	Rec = type {x:: int, y:: int}.
	test = function(a:: int, b::int):: int; entry() {
	r1 = undef:: Rec.
	r2 = r1 : {[1] = b, [0] = a}:: Rec.

	r2["x"]
	}
	)";

	auto man = XreateManager::prepare(move(code));
	Fn2Args program = (Fn2Args) man->run();
	ASSERT_EQ(10, program(10, 11));
	}

	-TEST(Containers, DONE_RecUpdateInLoop1){
	+TEST(Containers, RecUpdateInLoop1){
	FILE* code = fopen("scripts/containers/RecUpdateInLoop1.xreate", "r");
	assert(code != nullptr);

	auto man = XreateManager::prepare(code);
	Fn1Args program = (Fn1Args) man->run();
	ASSERT_EQ(11, program(10));
	}

	-TEST(Containers, DONE_ArrayInit1){
	+TEST(Containers, ArrayInit1){
	XreateManager* man = XreateManager::prepare(
	R"Code(
	main = function(x:: int):: int; entry() {
	a = {1, 2, 3}:: [int].
	a[x]
	}
	)Code");

	void* mainPtr = man->run();
	Fn1Args main = (Fn1Args) mainPtr;
	ASSERT_EQ(2, main(1));

	delete man;
	}

	-TEST(Containers, DONE_ArrayUpdate1){
	+TEST(Containers, ArrayUpdate1){
	XreateManager* man = XreateManager::prepare(R"(
	main = function(x::int):: int; entry()
	{
	a = {1, 2, 3}:: [int]; csize(5).
	b = a : {[1] = x}:: [int]; csize(5).
	b[1]
	}
	)");

	void* mainPtr = man->run();
	Fn1Args main = (Fn1Args) mainPtr;
	ASSERT_EQ(2, main(2));

	delete man;
	}

	-TEST(Containers, ListAsArray2){
	- XreateManager* man = XreateManager::prepare(
	-
	-R"Code(
	- // CONTAINERS
	- import raw("scripts/dfa/ast-attachments.lp").
	- import raw("scripts/containers/containers.lp").
	-
	- main = function:: int;entry {
	- a= {1, 2, 3}:: [int].
	- b= loop map(a->el:: int):: [int]{
	- 2 * el
	- }.
	-
	- sum = loop fold(b->el:: int, 0->acc):: int {
	- acc + el
	- }.
	-
	- sum
	- }
	-)Code");
	-
	- void* mainPtr = man->run();
	- FnNoArgs main = (FnNoArgs) mainPtr;
	- ASSERT_EQ(12, main());
	-
	- delete man;
	-}
	-
	-TEST(Containers, Doc_RecField1){
	- string code_Variants1 = getDocumentationExampleById("documentation/Syntax/syntax.xml", "RecField1");
	- XreateManager::prepare(move(code_Variants1));
	-
	- ASSERT_TRUE(true);
	-}
	-
	-TEST(Containers, Doc_RecUpdate1){
	- string code_Variants1 = getDocumentationExampleById("documentation/Syntax/syntax.xml", "RecUpdate1");
	- XreateManager::prepare(move(code_Variants1));
	-
	- ASSERT_TRUE(true);
	+TEST(Containers, FlyMap1){
	+ std::unique_ptr<XreateManager> man(XreateManager::prepare(R"(
	+main = function:: int; entry()
	+{
	+ x = {1, 2, 3, 4}:: [int].
	+ y = loop map(x->el::int)::[int]; fly(csize(4))
	+ {2 * el:: int }.
	+ loop fold((y::[int]; fly(csize(4)))->el:: int, 0->sum):: int {sum + el}-20
	}
	+)"));

	-TEST(Containers, ContanierLinkedList1){
	- 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 Symbol symb_chilrenRaw{body->getSymbol("childrenRaw"), body};
	-
	- containers::ImplementationLinkedList iLL(symb_chilrenRaw);
	-
	- ASSERT_EQ(true, static_cast<bool>(iLL));
	- ASSERT_EQ("next", iLL.fieldPointer);
	-
	- Implementation impl = Implementation::create(symb_chilrenRaw);
	- ASSERT_NO_FATAL_FAILURE(impl.extract<ON_THE_FLY>());
	-
	- ImplementationRec<ON_THE_FLY> recOnthefly = impl.extract<ON_THE_FLY>();
	- ASSERT_EQ(symb_chilrenRaw, recOnthefly.source);
	+ FnNoArgs mainFn = (FnNoArgs) man->run();
	+ intmax_t valueMain = mainFn();
	+ ASSERT_EQ(0, valueMain);
	}

	-TEST(Containers, Implementation_LinkedListFull){
	- FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate","r");
	- assert(input != nullptr);
	-
	- std::unique_ptr<XreateManager> program(XreateManager::prepare(input));
	- void* mainPtr = program->run();
	- int (main)() = (int ()())(intptr_t)mainPtr;
	-
	- intmax_t answer = main();
	- ASSERT_EQ(17, answer);
	-
	- fclose(input);
	+intmax_t fn_BUG_Triple(FnTuple3 callee){
	+ Tuple3 result = callee();
	+ return result.a+ result.b + result.c;
	}
	+TEST(Containers, BUG_Triple){
	+ std::unique_ptr<XreateManager> man(XreateManager::prepare(R"(
	+Tuple2 = type {int, int}.
	+Tuple3 = type {int, int, int}.
	+Tuple4 = type {int, int, int, int}.

	-TEST(Containers, Doc_Intr_1){
	- string example = R"Code(
	- import raw("scripts/containers/containers.lp").
	-
	- test = function:: int; entry
	- {
	- <BODY>
	- x
	- }
	- )Code";
	- string body = getDocumentationExampleById("documentation/Concepts/containers.xml", "Intr_1");
	- replace(example, "<BODY>", body);
	-
	- XreateManager* xreate = XreateManager::prepare(move(example));
	- FnNoArgs program = (FnNoArgs) xreate->run();
	-
	- intmax_t result = program();
	- ASSERT_EQ(1, result);
	+main = function:: Tuple3; entry()
	+{
	+ {1, 2, 3}
	}
	+)"));
	+ FnTuple3 mainFn = (FnTuple3) man->run();
	+ intmax_t result = fn_BUG_Triple(mainFn);

	-TEST(Containers, Doc_OpAccessSeq_1){
	- string example = getDocumentationExampleById("documentation/Concepts/containers.xml", "OpAccessSeq_1");
	- XreateManager* xreate = XreateManager::prepare(move(example));
	- FnNoArgs program = (FnNoArgs) xreate->run();
	-
	- intmax_t result = program();
	- ASSERT_EQ(15, result);
	+ ASSERT_EQ(6, result);
	+// ASSERT_EQ(2, result.b);
	+// ASSERT_EQ(3, result.c);
	}

	-TEST(Containers, Doc_OpAccessRand_1){
	- string example = getDocumentationExampleById("documentation/Concepts/containers.xml", "OpAccessRand_1");
	- XreateManager* xreate = XreateManager::prepare(move(example));
	- FnNoArgs program = (FnNoArgs) xreate->run();
	-
	- intmax_t result = program();
	- ASSERT_EQ(2, result);
	-}
	+TEST(Containers, ArrayArg1){
	+ FILE* code = fopen("scripts/containers/array_arg_1.xreate", "r");
	+ assert(code != nullptr);

	-TEST(Containers, Doc_ASTAttach_1){
	- string example = getDocumentationExampleById("documentation/Concepts/containers.xml", "ASTAttach_1");
	- string outputExpected = "containers_impl(s(1,-2,0),onthefly)";
	- XreateManager* xreate = XreateManager::prepare(move(example));
	-
	- testing::internal::CaptureStdout();
	- xreate->run();
	- std::string outputActual = testing::internal::GetCapturedStdout();
	-
	- ASSERT_NE(std::string::npos, outputActual.find(outputExpected));
	+ std::unique_ptr<XreateManager> man (XreateManager::prepare(code));
	+ FnNoArgs mainFn = (FnNoArgs) man->run();
	+ ASSERT_EQ(0, mainFn());
	}

	-TEST(Containers, IntrinsicArrInit1){
	- XreateManager* man = XreateManager::prepare(

	-R"Code(
	-FnAnns = type predicate {
	- entry
	-}
	-
	-main = function(x:: int):: int; entry() {
	- a{0} = intrinsic array_init(16):: [int].
	- a{1} = a{0} + {15: 12}
	-}
	-)Code");
	-}
	+//TEST(Containers, ListAsArray2){
	+// XreateManager* man = XreateManager::prepare(
	+//
	+//R"Code(
	+// // CONTAINERS
	+// import raw("scripts/dfa/ast-attachments.lp").
	+// import raw("scripts/containers/containers.lp").
	+//
	+// main = function:: int;entry {
	+// a= {1, 2, 3}:: [int].
	+// b= loop map(a->el:: int):: [int]{
	+// 2 * el
	+// }.
	+//
	+// sum = loop fold(b->el:: int, 0->acc):: int {
	+// acc + el
	+// }.
	+//
	+// sum
	+// }
	+//)Code");
	+//
	+// void* mainPtr = man->run();
	+// FnNoArgs main = (FnNoArgs) mainPtr;
	+// ASSERT_EQ(12, main());
	+//
	+// delete man;
	+//}
	+//
	+//TEST(Containers, Doc_RecField1){
	+// string code_Variants1 = getDocumentationExampleById("documentation/Syntax/syntax.xml", "RecField1");
	+// XreateManager::prepare(move(code_Variants1));
	+//
	+// ASSERT_TRUE(true);
	+//}
	+//
	+//TEST(Containers, Doc_RecUpdate1){
	+// string code_Variants1 = getDocumentationExampleById("documentation/Syntax/syntax.xml", "RecUpdate1");
	+// XreateManager::prepare(move(code_Variants1));
	+//
	+// ASSERT_TRUE(true);
	+//}
	+//
	+//TEST(Containers, ContanierLinkedList1){
	+// 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 Symbol symb_chilrenRaw{body->getSymbol("childrenRaw"), body};
	+//
	+// containers::ImplementationLinkedList iLL(symb_chilrenRaw);
	+//
	+// ASSERT_EQ(true, static_cast<bool>(iLL));
	+// ASSERT_EQ("next", iLL.fieldPointer);
	+//
	+// Implementation impl = Implementation::create(symb_chilrenRaw);
	+// ASSERT_NO_FATAL_FAILURE(impl.extract<ON_THE_FLY>());
	+//
	+// ImplementationRec<ON_THE_FLY> recOnthefly = impl.extract<ON_THE_FLY>();
	+// ASSERT_EQ(symb_chilrenRaw, recOnthefly.source);
	+//}
	+//
	+//TEST(Containers, Implementation_LinkedListFull){
	+// FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate","r");
	+// assert(input != nullptr);
	+//
	+// std::unique_ptr<XreateManager> program(XreateManager::prepare(input));
	+// void* mainPtr = program->run();
	+// int (main)() = (int ()())(intptr_t)mainPtr;
	+//
	+// intmax_t answer = main();
	+// ASSERT_EQ(17, answer);
	+//
	+// fclose(input);
	+//}
	+//
	+//TEST(Containers, Doc_Intr_1){
	+// string example = R"Code(
	+// import raw("scripts/containers/containers.lp").
	+//
	+// test = function:: int; entry
	+// {
	+// <BODY>
	+// x
	+// }
	+// )Code";
	+// string body = getDocumentationExampleById("documentation/Concepts/containers.xml", "Intr_1");
	+// replace(example, "<BODY>", body);
	+//
	+// XreateManager* xreate = XreateManager::prepare(move(example));
	+// FnNoArgs program = (FnNoArgs) xreate->run();
	+//
	+// intmax_t result = program();
	+// ASSERT_EQ(1, result);
	+//}
	+//
	+//TEST(Containers, Doc_OpAccessSeq_1){
	+// string example = getDocumentationExampleById("documentation/Concepts/containers.xml", "OpAccessSeq_1");
	+// XreateManager* xreate = XreateManager::prepare(move(example));
	+// FnNoArgs program = (FnNoArgs) xreate->run();
	+//
	+// intmax_t result = program();
	+// ASSERT_EQ(15, result);
	+//}
	+//
	+//TEST(Containers, Doc_OpAccessRand_1){
	+// string example = getDocumentationExampleById("documentation/Concepts/containers.xml", "OpAccessRand_1");
	+// XreateManager* xreate = XreateManager::prepare(move(example));
	+// FnNoArgs program = (FnNoArgs) xreate->run();
	+//
	+// intmax_t result = program();
	+// ASSERT_EQ(2, result);
	+//}
	+//
	+//TEST(Containers, Doc_ASTAttach_1){
	+// string example = getDocumentationExampleById("documentation/Concepts/containers.xml", "ASTAttach_1");
	+// string outputExpected = "containers_impl(s(1,-2,0),onthefly)";
	+// XreateManager* xreate = XreateManager::prepare(move(example));
	+//
	+// testing::internal::CaptureStdout();
	+// xreate->run();
	+// std::string outputActual = testing::internal::GetCapturedStdout();
	+//
	+// ASSERT_NE(std::string::npos, outputActual.find(outputExpected));
	+//}
	+//
	+//TEST(Containers, IntrinsicArrInit1){
	+// XreateManager* man = XreateManager::prepare(
	+//
	+//R"Code(
	+//FnAnns = type predicate {
	+// entry
	+//}
	+//
	+//main = function(x:: int):: int; entry() {
	+// a{0} = intrinsic array_init(16):: [int].
	+// a{1} = a{0} + {15: 12}
	+//}
	+//)Code");
	+//}
	diff --git a/cpp/tests/problems.cpp b/cpp/tests/problems.cpp
	index 1ea7797..054fa66 100644
	--- a/cpp/tests/problems.cpp
	+++ b/cpp/tests/problems.cpp
	@@ -1,134 +1,188 @@
	//
	// Created by pgess on 26/03/2020.
	//

	#include "xreatemanager.h"
	#include "pass/compilepass.h"
	#include "llvmlayer.h"
	#include "supplemental/basics.h"

	#include "gtest/gtest.h"

	using namespace xreate;

	-TEST(Problems, MinMax1){
	- struct Pair {intmax_t x; intmax_t y;};
	- typedef Pair (*FnPair)();
	+struct Pair {intmax_t x; intmax_t y;};
	+typedef Pair (*FnPair)();
	+
	+struct Tuple3 {intmax_t x; intmax_t y; intmax_t z; };
	+typedef Tuple3 (*FnTuple3)();
	+
	+//struct Tuple4 {Pair x; Pair y;};
	+struct Tuple4 {intmax_t a; intmax_t b; intmax_t c; intmax_t d;};
	+typedef Tuple4 (*FnTuple4)();

	+TEST(Problems, MinMax1){
	FILE* code = fopen("scripts/containers/minmax.xreate", "r");
	assert(code != nullptr);

	auto man = details::tier1::XreateManager::prepare(code);
	LLVMLayer* llvm = man->llvm;
	man->analyse();

	std::unique_ptr<CompilePass> compiler(new compilation::CompilePassCustomDecorators<>(man));
	compiler->prepare();
	llvm::Function* fnMinMax1Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax1"))->compile();
	llvm::Function* fnMinMax2Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax2"))->compile();
	llvm::Function* fnMinMax3Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax3"))->compile();
	llvm::Function* fnMinMax4Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax4"))->compile();
	llvm::Function* fnMinMax5Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax5"))->compile();
	llvm::Function* fnMinMax6Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax6"))->compile();
	llvm::Function* fnMinMax7Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax7"))->compile();
	llvm::Function* fnMinMax8Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax8"))->compile();
	llvm::Function* fnMinMax9Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax9"))->compile();
	llvm::Function* fnMinMax10Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax10"))->compile();
	llvm::Function* fnMinMax11Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax11"))->compile();
	llvm::Function* fnMinMax12Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax12"))->compile();
	llvm::Function* fnMinMax13Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax13"))->compile();
	llvm::Function* fnMinMax14Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax14"))->compile();
	+ llvm::Function* fnMinMax15Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax15"))->compile();
	+ llvm::Function* fnMinMax19Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax19"))->compile();
	+ llvm::Function* fnMinMax20Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax20"))->compile();
	+ llvm::Function* fnMinMax21Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax21"))->compile();
	+ llvm::Function* fnMinMax22Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax22"))->compile();
	+ llvm::Function* fnMinMax23Raw = compiler->getFunctionUnit(man->root->findFunction("fn-minmax23"))->compile();
	llvm->print();

	llvm->initJit();
	{
	FnPair fnMinxMax1 = (FnPair) llvm->getFunctionPointer(fnMinMax1Raw);
	Pair resultMinMax1 = fnMinxMax1();
	ASSERT_EQ(3, resultMinMax1.x);
	ASSERT_EQ(37, resultMinMax1.y);
	}

	{
	FnNoArgs fnMinMax2 = (FnNoArgs) llvm->getFunctionPointer(fnMinMax2Raw);
	intmax_t resultMinMax2 = fnMinMax2();
	ASSERT_EQ(10, resultMinMax2);
	}

	{
	FnNoArgs fnMinMax3 = (FnNoArgs) llvm->getFunctionPointer(fnMinMax3Raw);
	intmax_t resultMinMax3 = fnMinMax3();
	ASSERT_EQ(146, resultMinMax3);
	}

	{
	FnNoArgs fnMinMax4 = (FnNoArgs) llvm->getFunctionPointer(fnMinMax4Raw);
	intmax_t resultMinMax4 = fnMinMax4();
	ASSERT_EQ(6, resultMinMax4);
	}

	{
	FnPair fnMinMax5 = (FnPair) llvm->getFunctionPointer(fnMinMax5Raw);
	Pair resultMinMax5 = fnMinMax5();
	ASSERT_EQ(4, resultMinMax5.x);
	ASSERT_EQ(11, resultMinMax5.y);
	}

	{
	FnPair fnMinMax6 = (FnPair) llvm->getFunctionPointer(fnMinMax6Raw);
	Pair resultMinMax6 = fnMinMax6();
	ASSERT_EQ(2, resultMinMax6.x);
	ASSERT_EQ(8, resultMinMax6.y);
	}

	{
	FnPair fnMinMax7 = (FnPair) llvm->getFunctionPointer(fnMinMax7Raw);
	Pair resultMinMax7 = fnMinMax7();
	ASSERT_EQ(1, resultMinMax7.x);
	ASSERT_EQ(3, resultMinMax7.y);
	}

	{
	FnPair fnMinMax8 = (FnPair) llvm->getFunctionPointer(fnMinMax8Raw);
	Pair resultMinMax8 = fnMinMax8();
	ASSERT_EQ(2, resultMinMax8.x);
	ASSERT_EQ(3, resultMinMax8.y);
	}

	{
	FnPair fnMinMax9 = (FnPair) llvm->getFunctionPointer(fnMinMax9Raw);
	Pair resultMinMax9 = fnMinMax9();
	ASSERT_EQ(1, resultMinMax9.x);
	ASSERT_EQ(8, resultMinMax9.y);
	}

	{
	FnNoArgs fnMinMax10 = (FnNoArgs ) llvm->getFunctionPointer(fnMinMax10Raw);
	intmax_t resultMinMax10 = fnMinMax10();
	ASSERT_EQ(1, resultMinMax10);
	}

	{
	FnNoArgs fnMinMax11 = (FnNoArgs ) llvm->getFunctionPointer(fnMinMax11Raw);
	intmax_t resultMinMax11 = fnMinMax11();
	ASSERT_EQ(8, resultMinMax11);
	}

	{
	FnNoArgs fnMinMax12 = (FnNoArgs ) llvm->getFunctionPointer(fnMinMax12Raw);
	intmax_t resultMinMax12 = fnMinMax12();
	ASSERT_EQ(2, resultMinMax12);
	}

	{
	FnNoArgs fnMinMax13 = (FnNoArgs ) llvm->getFunctionPointer(fnMinMax13Raw);
	intmax_t resultMinMax13 = fnMinMax13();
	ASSERT_EQ(3, resultMinMax13);
	}

	{
	FnPair fnMinMax14 = (FnPair) llvm->getFunctionPointer(fnMinMax14Raw);
	Pair resultMinMax14 = fnMinMax14();
	ASSERT_EQ(2, resultMinMax14.x);
	ASSERT_EQ(3, resultMinMax14.y);
	}
	+
	+ {
	+ FnPair fnMinMax15 = (FnPair) llvm->getFunctionPointer(fnMinMax15Raw);
	+ Pair resultMinMax15 = fnMinMax15();
	+ ASSERT_EQ(1, resultMinMax15.x);
	+ ASSERT_EQ(16, resultMinMax15.y);
	+ }
	+
	+ {
	+ FnNoArgs fnMinMax19 = (FnNoArgs) llvm->getFunctionPointer(fnMinMax19Raw);
	+ intmax_t resultMinMax19 = fnMinMax19();
	+ ASSERT_EQ(3, resultMinMax19);
	+ }
	+
	+ {
	+ FnNoArgs fnMinMax20 = (FnNoArgs) llvm->getFunctionPointer(fnMinMax20Raw);
	+ intmax_t resultMinMax20 = fnMinMax20();
	+ ASSERT_EQ(4, resultMinMax20);
	+ }
	+
	+ {
	+ FnNoArgs fnMinMax21 = (FnNoArgs) llvm->getFunctionPointer(fnMinMax21Raw);
	+ intmax_t resultMinMax21 = fnMinMax21();
	+ ASSERT_EQ(5, resultMinMax21);
	+ }
	+
	+ {
	+ FnPair fnMinMax22 = (FnPair) llvm->getFunctionPointer(fnMinMax22Raw);
	+ Pair resultMinMax22 = fnMinMax22();
	+ ASSERT_EQ(-29, resultMinMax22.x);
	+ ASSERT_EQ(-14, resultMinMax22.y);
	+ }
	+
	+ {
	+ FnTuple4 fnMinMax23 = (FnTuple4) llvm->getFunctionPointer(fnMinMax23Raw);
	+ Tuple4 resultMinMax23 = fnMinMax23();
	+
	+ ASSERT_EQ(96, resultMinMax23.a);
	+ ASSERT_EQ(63, resultMinMax23.b);
	+ ASSERT_EQ(28, resultMinMax23.c);
	+ }
	}
	\ No newline at end of file
	diff --git a/grammar/xreate.ATG b/grammar/xreate.ATG
	index 8670b4e..307d0a6 100644
	--- a/grammar/xreate.ATG
	+++ b/grammar/xreate.ATG
	@@ -1,836 +1,836 @@
	//TODO add ListLiteral
	//TODO ExprTyped: assign default(none) type

	#include "ast.h"
	#include "ExternLayer.h"
	#include <string>
	#include <stack>
	#include <sstream>

	#define wprintf(format, ...) \
	char __buffer[100]; \
	wcstombs(__buffer, format, 100); \
	fprintf(stderr, __buffer, __VA_ARGS__)

	using namespace std;

	COMPILER Xreate

	details::inconsistent::AST* root = nullptr; // current program unit

	void SemErr(std::initializer_list<std::wstring> msgs){
	std::wstringstream output;
	for(const auto& msg: msgs){output << msg;}
	SemErr(output.str().c_str());
	}

	void ensureInitalizedAST(){
	if (root == nullptr) root = new details::inconsistent::AST();
	}

	struct {
	std::stack<CodeScope*> scopesOld;
	CodeScope* scope = nullptr;
	} context;

	void pushContextScope(CodeScope* scope){
	context.scopesOld.push(context.scope);
	context.scope = scope;
	}

	void popContextScope(){
	context.scope = context.scopesOld.top();
	context.scopesOld.pop();
	}

	int nextToken()
	{
	scanner->ResetPeek();
	return scanner->Peek()->kind;
	}

	bool checkTokenAfterIdent(int key){
	if (la->kind != _ident) return false;
	return nextToken() == key;
	}

	bool checkParametersList()
	{
	return la->kind == _ident && nextToken() == _lparen;
	}

	bool checkInfix()
	{
	return la->kind == _ident && nextToken() == _ident;
	}

	bool checkIndex()
	{
	return la->kind == _ident && nextToken() == _lbrack;
	}

	bool checkListIndex()
	{
	return la->kind == _lcurbrack && nextToken() == _lbrack;
	}

	bool checkFuncDecl()
	{
	if (la->kind != _ident) return false;

	int token2 = nextToken();
	int token3 = scanner->Peek()->kind;

	return token2 == _assign && token3 == _function;
	}

	bool checkAssignment()
	{
	if (la->kind != _ident) return false;

	scanner->ResetPeek();
	int token2 = scanner->Peek()->kind;
	if (token2 == _lcurbrack) {
	scanner->Peek();
	int token3 = scanner->Peek()->kind;
	if (token3 != _rcurbrack) return false;

	int token4 = scanner->Peek()->kind;
	return token4 == _assign;
	}

	return token2 == _assign;
	}

	void recognizeIdentifier(Expression& id, const std::wstring& hint){
	if (!context.scope)
	SemErr({L"Identifier found in undefined scope: ", hint});

	if (!context.scope->recognizeIdentifier(id)){
	root->postponeIdentifier(context.scope, id);
	}
	}

	enum SwitchKind{SWITCH_NORMAL, SWITCH_META};

	CHARACTERS
	letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
	any = ANY - '"'.
	digit = "0123456789".
	cr = '\r'.
	lf = '\n'.
	tab = '\t'.

	TOKENS
	ident = (letter ['-' letter] \| '_') {letter ['-' letter] \| digit \| '_' }.
	number = digit{digit}.
	string = '"' { any } '"'.
	function = "function".
	comma = ','.
	period = '.'.
	lparen = '('.
	rparen = ')'.
	lbrack = '['.
	rbrack = ']'.
	lcurbrack = '{'.
	rcurbrack = '}'.
	equal = "==".
	assign = '='.
	implic = '-' '>'.
	colon = ':'.
	tagcolon = "::".
	lse = "<=".
	lss = "<".
	gte = ">=".
	gtr = ">".

	ne1 = "!=".
	ne2= "<>".


	COMMENTS FROM "/" TO "/" NESTED
	COMMENTS FROM "//" TO lf

	IGNORE cr + lf + tab

	PRODUCTIONS

	Xreate = (. Function* function; ensureInitalizedAST(); .)
	{( //RuleDecl
	InterfaceData \| Imprt \| GuardSection
	\| IF(checkFuncDecl()) FDecl<function> (. root->add(function); .)
	\| TDecl
	\| SkipModulesSection
	)} (. .)
	.

	Ident<std::wstring& name>=
	ident (. name = t->val; .).

	// recognition
	IdentR<Expression &e> = (. std::wstring name; .)
	Ident<name> (. e = Expression(Atom<Identifier_t>(name)); .)
	(. recognizeIdentifier(e, name); .).

	//versioning
	IdentV<Expression& e>= (. std::wstring name; .)
	Ident<name> (. e = Expression(Atom<Identifier_t>(name)); .)
	[ Version<e> ].

	//recognition + versioning
	IdentVR<Expression& e>= (. std::wstring name; .)
	Ident<name> (. e = Expression(Atom<Identifier_t>(name)); .)
	[ Version<e> ] (. recognizeIdentifier(e, name); .)
	.

	Version<Expression &e>=
	lcurbrack (
	ident (. SemErr({L"var version as ident is not implemented yet"}); .)
	\| number (. Attachments::put<versions::VariableVersion>(e, Atom<Number_t>(t->val).get()); .)
	) rcurbrack .


	FDecl<Function*& f> = (. std::wstring fname; std::wstring argName; TypeAnnotation typIn; TypeAnnotation typOut; Expression binding; .)
	Ident<fname> assign
	function (. f = new Function(fname); CodeScope* entry = f->getEntryScope(); .)

	[lparen Ident<argName> tagcolon ExprAnnotations<binding> (. f->addBinding(Atom<Identifier_t>(argName), move(binding)); .)
	{comma Ident<argName> tagcolon ExprAnnotations<binding> (. f->addBinding(Atom <Identifier_t>(argName), move(binding));.)
	} rparen]

	-[ tagcolon Type<typOut> {';' FnTag<f> }]
	+tagcolon Type<typOut> {';' FnTag<f> }
	BDecl<entry> (. const_cast<Expression&>(entry->getBody()).bindType(move(typOut));.)
	.

	GuardSection<>= (. std::wstring arg, guardI; Expression guardE, guardBinding; Function* f; TypeAnnotation guardT; .)
	"guard" lparen
	[Ident<arg>] tagcolon Ident<guardI> (. guardE = Expression(Operator::CALL, {Atom<Identifier_t>(guardI)}); bool res = root->recognizeVariantConstructor(guardE); .)
	(. if(!res) SemErr(coco_string_create("Can't recognize a guard"));.)
	(. if (!arg.empty()) guardE.addBindings({Atom<Identifier_t>(arg)}); .)
	(. guardBinding.type = TypeAnnotation(TypeOperator::GUARD, {guardE.type}); guardBinding.type.__valueCustom = Atom<Identifier_t>(guardI).get(); .)
	rparen lcurbrack {
	FDecl<f> (. f->guard = guardE; if (!arg.empty()){f->addBinding(Atom<Identifier_t>(arg), Expression(guardBinding));} .)
	(. root->add(f); .)
	} rcurbrack
	.


	/**
	* TYPES
	*
	*/
	TypeTerm<TypePrimitive& typ> = (. std::wstring tid; .)
	( "string" (. typ = TypePrimitive::String;.)
	\| "int" (. typ = TypePrimitive::Int;.)
	\| "float" (. typ = TypePrimitive::Float;.)
	\| "bool" (. typ = TypePrimitive::Bool; .)
	\| "i8" (. typ = TypePrimitive::I8; .)
	\| "i32" (. typ = TypePrimitive::I32; .)
	\| "i64" (. typ = TypePrimitive::I64; .)
	).

	Type<TypeAnnotation& typ> = (. TypeAnnotation typ2; TypePrimitive typ3; std::wstring tid; std::string field; .)
	(
	TList<typ>
	\| TRecord<typ>
	\| TVariant<typ>
	\| TPred<typ>
	\| TSlave<typ>
	\| TRef<typ>
	\| TypeTerm<typ3> (. typ = typ3; .)
	\| IF (checkIndex()) Ident<tid> lbrack
	TypeIndex<field> (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); typ.fields.push_back(field); .)
	{comma TypeIndex<field> (. typ.fields.push_back(field); .)
	} rbrack

	\| Ident<tid> (. typ = TypeAnnotation(TypeOperator::ALIAS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); .)
	[lparen Type<typ2> (. typ.__operands.push_back(typ2); .)
	{comma Type<typ2> (. typ.__operands.push_back(typ2); .)
	} rparen]
	\| '*' (.typ = TypeAnnotation(); .)
	) .

	TypeIndex<std::string& name> =
	(
	number (. name = Atom<Identifier_t>(t->val).get(); .)
	\| string (. name = Atom<String_t>(t->val).get(); .)
	)
	.

	TList<TypeAnnotation& typ> = (. TypeAnnotation ty; .)
	lbrack Type<ty> rbrack (. typ = TypeAnnotation(TypeOperator::ARRAY, {ty}); .)
	.

	TRecordBody<TypeAnnotation& typ> =
	(. TypeAnnotation t; std::wstring key; size_t keyCounter=0;
	typ = TypeAnnotation(TypeOperator::RECORD, {});
	.)
	{
	(
	IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon
	\| (. key = to_wstring(keyCounter++); .)
	)
	Type<t> [comma] (. typ.__operands.push_back(t); .)
	(. typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
	}.

	TRecord<TypeAnnotation& typ> =
	lcurbrack TRecordBody<typ> rcurbrack
	(. if(!typ.__operands.size()) SemErr(coco_string_create("Record type can't be empty.")); .)
	.

	TVariantRec<TypeAnnotation& typ> = (. TypeAnnotation typVoid; .)
	lparen TRecordBody<typ> rparen
	(. if(typ.__operands.size()==0) typ = typVoid; .)
	.

	TVariantBody<TypeAnnotation& typ> = (. TypeAnnotation t, typVoid; std::vector<TypeAnnotation> operands; std::vector<Atom<Identifier_t>> keys; std::wstring v; .)
	lcurbrack
	{ (. t = typVoid; .)
	Ident<v> [TVariantRec<t>] (. keys.push_back(Atom<Identifier_t>(v)); operands.push_back(t); .)
	[comma]
	}
	rcurbrack
	(. typ = TypeAnnotation(TypeOperator::VARIANT, {});
	typ.__operands = operands;
	typ.addFields(std::move(keys));
	.)
	.

	TVariant<TypeAnnotation& typ>=
	"variant" TVariantBody<typ>
	(. if(!typ.__operands.size()) SemErr(coco_string_create("Variant type can't be empty.")); .)
	.

	TPred<TypeAnnotation& typ>=
	"predicate" TVariantBody<typ>
	(. if(!typ.__operands.size()) SemErr(coco_string_create("Predicate type can't be empty.")); .)
	.

	TSlave<TypeAnnotation& typ>=
	"slave" (. typ = TypeAnnotation(TypeOperator::SLAVE, {}); .)
	lparen
	string (. typ.__valueCustom = Atom<String_t>(t->val).get(); .)
	rparen
	.

	TRef<TypeAnnotation& typ>= (. TypeAnnotation typChild; .)
	"ref" lparen Type<typChild> rparen (. typ = TypeAnnotation(TypeOperator::REF, {typChild}); .)
	.

	TDecl = (. TypeAnnotation t; std::wstring tname, arg; std::vector<Atom<Identifier_t>> args; .)
	Ident<tname> assign "type"
	[lparen Ident<arg> (. args.push_back(Atom<Identifier_t>(arg)); .)
	{comma Ident<arg> (. args.push_back(Atom<Identifier_t>(arg)); .)
	} rparen]
	Type<t>[period] (. t.addBindings(move(args)); root->add(move(t), Atom<Identifier_t>(tname)); .)
	.

	ContextDecl<CodeScope * scope> = (. Expression tag; .)
	"context" tagcolon
	MetaSimpExpr<tag> (. scope->tags.push_back(tag); .)
	{';' MetaSimpExpr<tag> (. scope->tags.push_back(tag); .)
	}.

	VDecl<CodeScope* f> = (. Expression var, value;.)
	IdentV<var> assign ExprTyped<value> (. Symbol identSymbol = f->addDefinition(move(var), move(value));
	Attachments::put<ExprAlias_A>(value, identSymbol);
	.)
	.

	BDecl<CodeScope* scope> = lcurbrack (. Expression body; pushContextScope(scope); bool flagBodyFound = false; .)
	{(IF(checkAssignment()) VDecl<scope> period
	// \| RuleContextDecl<scope>
	\| ContextDecl<scope>period
	\| ExprTyped<body> (. scope->setBody(body); flagBodyFound = true; Attachments::put<ExprAlias_A>(body, Symbol{ScopedSymbol::RetSymbol, scope});.)
	)}
	rcurbrack (. if(!flagBodyFound) SemErr(coco_string_create("Code block with an empty body!"));
	popContextScope();
	.)
	.

	IfDecl<Expression& e> =
	(. Expression cond(Operator::AND, {}), condPart;
	ManagedScpPtr blockTrue = root->add(new CodeScope(context.scope));
	ManagedScpPtr blockFalse = root->add(new CodeScope(context.scope));
	e = Expression(Operator::IF, {});
	.)
	"if" lparen Expr<condPart> (. cond.operands.push_back(condPart); .)
	{ comma Expr<condPart> (. cond.operands.push_back(condPart); .)
	} rparen (. e.operands.push_back(cond); .)
	tagcolon ExprAnnotations<e>
	BDecl<&blockTrue> "else" BDecl<&blockFalse> (. e.addBlock(blockTrue); e.addBlock(blockFalse); .)
	.

	LoopDecl<Expression& e> =
	(.
	Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; Expression tagsEl;
	ManagedScpPtr block = root->add(new CodeScope(context.scope));
	.)
	"loop"
	(
	"map" lparen Expr<eIn> implic Ident<varEl>
	(. e = Expression(Operator::MAP, {eIn}); .)
	tagcolon ExprAnnotations<tagsEl> rparen tagcolon ExprAnnotations<e>
	(.
	e.addBindings({Atom<Identifier_t>(varEl)});
	block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)

	\| "fold" lparen Expr<eIn> implic Ident<varEl> tagcolon ExprAnnotations<tagsEl>
	['\|' Expr<eFilters> ] comma Expr<eAcc> implic Ident<varAcc>rparen
	(.
	e = Expression(Operator::FOLD, {eIn, eAcc});
	e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
	.)
	tagcolon ExprAnnotations<e>
	(.
	Expression varAccBindingE; varAccBindingE.type = e.type;
	block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	block->addBinding(Atom<Identifier_t>(varAcc), move(varAccBindingE));
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)
	\| lparen Expr<eAcc> implic Ident<varAcc> rparen
	(.
	e = Expression(Operator::FOLD_INF, {eAcc});
	e.addBindings({Atom<Identifier_t>(varAcc)});
	.)
	tagcolon ExprAnnotations<e>
	(.
	Expression varAccBindingE; varAccBindingE.type = e.type;
	block->addBinding(Atom<Identifier_t>(varAcc), move(varAccBindingE));
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)
	).

	// Switches
	SwitchDecl<Expression& eSwitch, SwitchKind flagSwitchKind> = (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); Expression eCondition; Expression tag;.)
	"switch"
	(
	SwitchVariantDecl<eSwitch>
	\| SwitchLateDecl<eSwitch>
	\| lparen ExprTyped<eCondition> rparen tagcolon ExprAnnotations<eSwitch> (. eSwitch.operands.push_back(eCondition);.)
	CaseDecl<eSwitch, flagSwitchKind> {CaseDecl<eSwitch, flagSwitchKind>}
	)
	.

	CaseDecl<Expression& outer, SwitchKind flagSwitchKind> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); Expression condition; .)
	"case"
	( IF(flagSwitchKind == SWITCH_META)
	lparen MetaSimpExpr<condition> rparen BDecl<&*scope> (. Expression exprCase(Operator::CASE, {}); exprCase.addTags({condition}); exprCase.addBlock(scope); outer.addArg(move(exprCase));.)

	\| "default" BDecl<&*scope> (. Expression exprCase(Operator::CASE_DEFAULT, {});
	exprCase.addBlock(scope);
	outer.operands.insert(++outer.operands.begin(), exprCase); .)

	\| lparen CaseParams<&scope> rparen (. ManagedScpPtr scopeBody = root->add(new CodeScope(&scope)); Expression exprCase(Operator::CASE, {}); .)
	BDecl<&*scopeBody> (. exprCase.addBlock(scope); exprCase.addBlock(scopeBody); outer.addArg(move(exprCase)); .)
	).

	CaseParams<CodeScope* scope> = (. Expression condition; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .)
	ExprTyped<condition> (. guard.addArg(Expression(condition)); .)
	{comma ExprTyped<condition> (. guard.addArg(Expression(condition)); .)
	} (. scope->setBody(guard); popContextScope(); .)
	.

	SwitchLateDecl<Expression& expr> =
	(.
	std::wstring aliasCondition; Expression exprCondition, aliasAnns;
	expr = Expression(Operator::SWITCH_LATE, {});
	ManagedScpPtr scope = root->add(new CodeScope(context.scope));
	.)

	"late" lparen Expr<exprCondition> [implic Ident<aliasCondition>] [tagcolon ExprAnnotations<aliasAnns>] rparen
	tagcolon ExprAnnotations<expr> BDecl<&*scope>
	(.
	expr.addArg(Expression(exprCondition));
	expr.addBlock(scope);
	std::string alias;
	if(aliasCondition.empty()){
	if(exprCondition.__state != Expression::IDENT){
	SemErr(coco_string_create("An identifier expected in the short form"));
	return;
	}

	//Use exprCondition as identifier
	alias = exprCondition.getValueString();
	} else {
	//Use aliasCondition
	alias = Atom<Identifier_t>(move(aliasCondition)).get();
	}

	expr.addBindings({Atom<Identifier_t>(string(alias))});
	scope->addBinding(Atom<Identifier_t>(move(alias)), move(aliasAnns));
	.)
	.

	SwitchVariantDecl<Expression& expr> =
	(. Expression varTested; std::wstring varAlias; bool flagAliasFound = false; expr = Expression(Operator::SWITCH_VARIANT, {}); .)

	"variant" lparen Expr<varTested> [implic Ident<varAlias>
	(. flagAliasFound = true; .)

	] [tagcolon ExprAnnotations<varTested>] rparen tagcolon ExprAnnotations<expr>
	(. expr.addArg(std::move(varTested));
	if (flagAliasFound) {
	expr.addBindings({Atom<Identifier_t>(varAlias)});

	} else {
	if(varTested.__state == Expression::IDENT){
	expr.addBindings({Atom<Identifier_t>(string(varTested.getValueString()))});
	}
	}
	.)

	CaseVariantDecl<expr> {CaseVariantDecl<expr>}
	.

	CaseVariantDecl<Expression& expr> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); std::wstring key; scope->addBinding(Atom<Identifier_t>(string(expr.bindings.front())), Expression()); .)
	"case" lparen Ident<key> rparen (. expr.addArg(root->recognizeVariantConstructor(Atom<Identifier_t>(std::move(key)))); .)
	BDecl<&*scope> (. expr.addBlock(scope); .)
	.

	IntrinsicDecl<Expression& outer>= (. std::wstring name; .)
	"intrinsic"
	(
	Ident< name>
	(. outer = Expression(Operator::CALL_INTRINSIC, {});
	outer.setValue(Atom<Identifier_t>(name));
	root->recognizeIntrinsic(outer);
	.)
	lparen [CalleeParams<outer>] rparen

	\| "query" (. outer = Expression(Operator::QUERY, {}); .)
	(
	"late" IntrinsicQueryLateDecl<outer>
	\| lparen [CalleeParams<outer>] rparen
	)
	).

	IntrinsicQueryLateDecl<Expression& expr> =
	(.
	std::wstring predicateAlias; Expression predicateE, predicateAnns;
	expr = Expression(Operator::QUERY_LATE, {});
	ManagedScpPtr scope = root->add(new CodeScope(context.scope));
	.)

	lparen Expr<predicateE> implic Ident<predicateAlias> tagcolon ExprAnnotations<predicateAnns> rparen
	tagcolon ExprAnnotations<expr> BDecl<&*scope>
	(.
	expr.addArg(move(predicateE));
	expr.addBindings({Atom<Identifier_t>(wstring(predicateAlias))});
	scope->addBinding(Atom<Identifier_t>(move(predicateAlias)), move(predicateAnns));
	expr.addBlock(scope);
	.)
	.

	SequenceDecl<Expression& sequence> = (. sequence = Expression(); sequence.setOp(Operator::SEQUENCE); ManagedScpPtr scope = root->add(new CodeScope(context.scope)); .)
	"seq" BDecl<&scope> (. sequence.blocks.push_back(&scope); scope = root->add(new CodeScope(&*scope)); .)
	{ (. scope = root->add(new CodeScope(&*scope)); .)
	BDecl<&scope> (. sequence.blocks.push_back(&scope); .)
	}.

	/============================ INTERFACES ===============================/
	Imprt<> =
	"import" "raw" lparen string (. root->__rawImports.push_back(Atom<String_t>(t->val).get()); .)
	rparen period.

	InterfaceData<> = "interface" lparen
	( "dfa" rparen InterfaceDFA
	// \| "extern-c" rparen InterfaceExternC
	\| "cfa" rparen InterfaceCFA
	).

	// InterfaceExternC<> = (. ExternData data; .)
	// lcurbrack {ExternHeadersDecl<data> \| ExternAliasDecl<data> } rcurbrack
	// (. root->addExternData(move(data)); .)
	// .
	//
	// ExternPkgDecl<std::wstring& package> =
	// "pkgconfig" lparen
	// string (. package = t->val.)
	// rparen
	// .
	//
	// ExternAliasDecl<ExternData& data> = (. std::wstring alias, package; .)
	// Ident<alias> assign "library" lparen ExternPkgDecl<package> rparen period
	// (. data.addLibAlias(Atom<Identifier_t>(alias), Atom<String_t>(package)); .)
	// .
	//
	// ExternHeadersDecl<ExternData& data> = (. std::list<std::string> listInc; std::wstring& package; .)
	// "include"
	// [lparen
	// (
	// Ident<alias> (. data.requireLibAlias(Atom<Identifier_t>(alias)); .)
	// \| ExternPkgDecl<package> (. data.requireLibPackage(Atom<String_t>(package)); .)
	// )
	// rparen]
	// lcurbrack { string (. listInc.push_back(Atom<String_t>(t->val).get()); .)
	// [comma] } rcurbrack [period] (. data.requireHeaders(listInc); .)
	// .

	InterfaceDFA<> = lcurbrack { InstructDecl } rcurbrack .

	InstructDecl = (.Operator op; Expression tag;
	Expression scheme;
	std::vector<Expression>& tags = scheme.operands;
	tags.push_back(Expression()); /* return value */ .)
	"operator" InstructAlias<op> tagcolon lparen (.scheme.setOp(op); .)
	[
	MetaSimpExpr<tag> (. tags.push_back(tag); .)
	{
	comma MetaSimpExpr<tag> (. tags.push_back(tag); .)
	}
	] rparen [ implic MetaSimpExpr<tag> (. tags[0] = tag; .)
	] (. root->addDFAData(move(scheme)); .)
	period.

	InstructAlias<Operator& op> =
	(
	"map" (. op = Operator::MAP; .)
	\| "list_range" (. op = Operator::LIST_RANGE; .)
	\| "list" (. op = Operator::LIST; .)
	\| "fold" (. op = Operator::FOLD; .)
	\| "index" (. op = Operator::INDEX; .)
	).


	InterfaceCFA<> = lcurbrack { InstructCFADecl } rcurbrack .

	InstructCFADecl<> = (.Operator op; Expression tag;
	Expression scheme;
	std::vector<Expression>& tags = scheme.operands; .)

	"operator" InstructAlias<op> tagcolon (. scheme.setOp(op); .)
	[
	MetaSimpExpr<tag> (. tags.push_back(tag); .)
	{
	comma MetaSimpExpr<tag> (. tags.push_back(tag); .)
	}
	] period (. root->addInterfaceData(CFA, move(scheme)); .).

	/============================ METAPROGRAMMING ===============================/
	// TagsDecl<CodeScope* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
	// ':' { MetaSimpExpr<tag> (. /f.addTag(std::move(tag), mod); / .)
	// }.


	FnTag<Function* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
	MetaSimpExpr<tag>
	['-' TagMod<mod>] (. f->addTag(std::move(tag), mod); .).

	TagMod<TagModifier& mod> =
	( "assert" (. mod = TagModifier::ASSERT; .)
	\| "require" (. mod = TagModifier::REQUIRE; .)
	).

	// RuleDecl<> =
	// "rule" tagcolon (. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .)
	// lparen Ident<arg> tagcolon Domain<typ> (. args.add(arg, typ); .)
	// {comma Ident<arg> tagcolon Domain<typ> (. args.add(arg, typ); .)
	// } rparen
	// ["case" RGuard<guards> {comma RGuard<guards>}]
	// lcurbrack RBody<args, guards> rcurbrack .

	/* - TODO use RGuard for guards-*/
	// RuleContextDecl<CodeScope* scope> = (.Expression eHead, eGuards, eBody; .)
	// "rule" "context" tagcolon MetaSimpExpr<eHead>
	// "case" lparen MetaSimpExpr<eGuards> rparen
	// lcurbrack MetaSimpExpr<eBody> rcurbrack (.scope->contextRules.push_back(Expression(Operator::CONTEXT_RULE, {eHead, eGuards, eBody})); .).

	// Domain<DomainAnnotation& dom> =
	// (
	// "function" (. dom = DomainAnnotation::FUNCTION; .)
	// \| "variable" (. dom = DomainAnnotation::VARIABLE; .)
	// ).

	// RGuard<RuleGuards& guards>= (. Expression e; .)
	// MetaExpr<e> (. guards.add(std::move(e)); .).

	// MetaExpr<Expression& e>= (.Operator op; Expression e2; .)
	// MetaExpr2<e>
	// [MetaOp<op> MetaExpr2<e2> (. e = Expression(op, {e, e2}); .)
	// ].

	// MetaExpr2<Expression& e>=
	// (
	// lparen MetaExpr<e> rparen
	// \| MetaSimpExpr<e>
	// ).

	MetaSimpExpr<Expression& e>= (. std::wstring i1, infix; Expression e2; .)
	(
	'-' MetaSimpExpr<e2> (. e = Expression(Operator::NEG, {e2}); .)
	\| IF(checkParametersList()) Ident<i1>
	(. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(i1))});
	if (!root->recognizeVariantConstructor(e))
	SemErr({L"Undefined predicate: ", i1});
	.)
	lparen [ MetaCalleeParams<e> ] rparen
	\| IF(checkInfix()) Ident<i1> Ident<infix> MetaSimpExpr<e2>
	(. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(infix))});
	e.addArg(Expression(Atom<Identifier_t>(i1)));
	e.addArg(std::move(e2));
	.)
	\| IdentR<e>
	\| number (. e = Expression(Atom<Number_t>(t->val)); .)
	).

	MetaCalleeParams<Expression& e> = (. Expression e2; .)
	MetaSimpExpr<e2> (. e.addArg(Expression(e2)); .)
	{comma MetaSimpExpr<e2> (. e.addArg(Expression(e2)); .)
	}.

	// RBody<const RuleArguments& args, const RuleGuards& guards> =
	// (. Expression e; std::wstring msg; .)
	// "warning" MetaExpr<e> ["message" string (. msg = t->val; .)
	// ] (. root->add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom<String_t>(msg))); .)
	// .

	// MetaOp< Operator& op> =
	// implic (. op = Operator::IMPL; .)
	// .

	/============================ Expressions ===============================/
	ExprAnnotations<Expression& e> = (. TypeAnnotation typ; std::list<Expression> tags; Expression tag; e.tags.clear();.)
	Type<typ> (. e.bindType(move(typ)); .)
	{';' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	} (. e.addTags(tags); .)
	.

	ExprTyped<Expression&e> = Expr<e> [tagcolon ExprAnnotations<e>].

	Expr< Expression& e> (. Expression e2; .)
	= ExprLogicAnd<e>
	[ ("or" \| "OR") Expr<e2> (. e = Expression(Operator::OR, {e, e2}); .)
	]
	.

	ExprLogicAnd< Expression& e> (. Expression e2; .)
	= ExprRel<e>
	[ ("and" \| "AND") ExprLogicAnd <e2> (. e = Expression(Operator::AND, {e, e2}); .)
	]
	.

	ExprRel< Expression& e> (. Operator op; Expression e2; .)
	= ExprArithmAdd<e>
	[ RelOp<op> ExprRel<e2> (. e = Expression(op, {e, e2}); .)
	]
	.

	ExprArithmAdd< Expression& e>= (. Operator op; Expression e2; .)
	ExprArithmMul< e>
	[
	AddOp<op>ExprArithmAdd< e2> (. e = Expression(op, {e, e2});.)
	].

	ExprArithmMul< Expression& e> (. Operator op; Expression e2; .)
	= ExprUpdate<e>
	[ MulOp< op>
	ExprArithmMul< e2> (. e = Expression(op, {e, e2}); .)
	].

	ExprUpdate<Expression& e>= (. Expression e2; .)
	ExprPostfix< e>
	[
	colon
	( IF(checkListIndex()) ListIndexLiteral<e2>
	\| ListLiteral<e2>) (. e = Expression(Operator::UPDATE, {e, e2}); .)
	].


	ExprPostfix<Expression& e>
	= Term<e>
	[ (. e = Expression(Operator::INDEX, {e}); .)
	{lbrack CalleeParams<e> rbrack }
	].


	Term< Expression& e> (. std::wstring name; e = Expression(); .)
	=
	(IF (checkParametersList()) Ident< name>
	(. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); root->recognizeVariantConstructor(e); .)
	lparen [CalleeParams<e>] rparen
	\| IdentVR<e>
	\| ListLiteral<e>
	\| ListRangeLiteral<e>
	\| LoopDecl<e>
	\| IfDecl<e>
	\| SwitchDecl<e, SWITCH_NORMAL>
	\| IntrinsicDecl<e>
	\| SequenceDecl<e>
	\| number (. e = Expression(Atom<Number_t>(t->val)); .)
	\| string (. e = Expression(Atom<String_t>(t->val)); .)
	\| "true" (. e = Expression(Atom<Number_t>(1)); e.bindType(TypePrimitive::Bool); .)
	\| "false" (. e = Expression(Atom<Number_t>(0)); e.bindType(TypePrimitive::Bool); .)
	\| "undef" (. e = Expression(Operator::UNDEF, {}); .)
	\| '-' Term<e> (. e = Expression(Operator::NEG, {e}); .)
	\| lparen ExprTyped<e> rparen
	).

	ListLiteral<Expression& e> = (. std::wstring key;
	Expression val;
	std::list<Atom<Identifier_t>> keys;
	e = Expression(Operator::LIST, {});
	.)
	lcurbrack {
	( IF(checkTokenAfterIdent(_assign)) Ident<key> assign
	\| (. key = L""; .)
	) Expr<val> (. keys.push_back(Atom<Identifier_t>(key));
	e.operands.push_back(val);
	.)
	[comma] } rcurbrack (. e.addBindings(keys.begin(), keys.end()); .)
	.

	ListIndexLiteral<Expression& e> = (. e = Expression(Operator::LIST_INDEX, {});Expression valE;.)
	lcurbrack
	{ (. Expression idxE(Operator::LIST, {});.)
	lbrack CalleeParams<idxE> rbrack
	assign Expr<valE>[comma] (. e.operands.push_back(idxE); e.operands.push_back(valE); .)
	}
	rcurbrack
	.

	ListRangeLiteral<Expression& e> = (. Expression eFrom, eTo; .)
	lbrack Expr<eFrom> ".." Expr<eTo> rbrack (. e = Expression(Operator::LIST_RANGE, {eFrom, eTo}); .)
	.


	CalleeParams<Expression& e> = (. Expression e2; .)
	ExprTyped<e2> (. e.addArg(Expression(e2)); .)
	{comma ExprTyped<e2> (. e.addArg(Expression(e2)); .)
	}.

	AddOp< Operator& op>
	= (. op = Operator::ADD; .)
	( '+'
	\| '-' (. op = Operator::SUB; .)
	).

	MulOp< Operator& op>
	= (. op = Operator::MUL; .)
	( '*'
	\| '/' (. op = Operator::DIV; .)
	\| '%' (. op = Operator::MOD; .)
	).

	RelOp< Operator& op>
	= (. op = Operator::EQU; .)
	( equal
	\| (ne1 \| ne2) (. op = Operator::NE; .)

	\| lse (. op = Operator::LSE; .)
	\| lss (. op = Operator::LSS; .)

	\| gte (. op = Operator::GTE; .)
	\| gtr (. op = Operator::GTR; .)

	).

	SkipModulesSection = "module" {ANY} (lcurbrack {ANY} rcurbrack \| '.').

	END Xreate.
	diff --git a/scripts/containers/minmax.xreate b/scripts/containers/minmax.xreate
	index 8532993..a9478cb 100644
	--- a/scripts/containers/minmax.xreate
	+++ b/scripts/containers/minmax.xreate
	@@ -1,282 +1,439 @@
	El = type {idx:: int, val:: int}.
	PairT = type(X) {X, X}.

	Pair = type PairT(int).
	PairEl = type PairT(El).

	min = function(x:: int, y:: int):: int
	{
	if (x < y):: int { x } else { y }
	}

	max = function(x:: int, y:: int):: int
	{
	if (x > y):: int { x } else { y }
	}

	minEl = function(e1:: El, e2:: El):: El
	{
	if (e1["val"] < e2["val"]):: El {e1} else {e2}
	}

	maxEl = function(e1:: El, e2:: El):: El
	{
	if (e1["val"] > e2["val"]):: El {e1} else {e2}
	}

	minElIdx = function(x:: El, y:: El):: El
	{
	if (x["idx"] < y["idx"]):: El {x} else {y}
	}

	maxElIdx = function(x:: El, y:: El):: El
	{
	if (x["idx"] > y["idx"]):: El {x} else {y}
	}

	minLstEl = function(x:: El, y:: El):: El
	{
	if (x["val"] <= y["val"]):: El {x} else {y}
	}

	maxLstEl = function(x:: El, y:: El):: El
	{
	if (x["val"] >= y["val"]):: El {x} else {y}
	}

	+OptionalVal = type {flag:: bool, val:: int}.
	+OptionalEl = type {el:: El, exists:: bool}.
	+
	+getOptionalEl = function(elActual:: OptionalEl, elDefault::El):: El
	+{
	+ if (elActual["exists"])::El {elActual["el"]} else {elDefault}
	+}
	+
	+inRange = function(val::int, range::Pair):: bool
	+{
	+ val >= range[0] and val <= range[1]
	+}
	+
	fn-minmax1 = function:: {min:: int, max:: int}
	{
	arr = {25, 37, 12, 6, 5, 19, 3, 20}:: [int].

	loop fold(arr->el:: int, {1000, 0}->state):: {min:: int, max:: int}
	{
	{
	min(el, state["min"]),
	max(el, state["max"])
	}:: {min:: int, max:: int}
	}
	}

	fn-minmax2 = function:: int
	{
	arr = {
	{1, 72}, {3, 8}, {2, 5}, {3, 4}, {11, 1}, {6, 5}, {9, 2}
	} :: [{int, int}].

	loop fold(arr->rect:: {int, int}, 1000->squareMin):: int
	{
	square = rect[0] * rect[1]:: int.

	min(square, squareMin)
	}
	}

	fn-minmax3 = function:: int
	{
	arr = {
	{1, 72}, {3, 8}, {2, 5}, {3, 4}, {11, 1}, {6, 5}, {9, 2}
	} :: [{int, int}].

	loop fold(arr->rect:: {int, int}, 0->perMax):: int
	{
	per = 2 * (rect[0] + rect[1]):: int.
	max(per, perMax)
	}
	}

	fn-minmax4 = function:: int
	{
	arr = {25, 37, 12, 6, 5, 19, 3, 20}:: [int].
	minInit = {0, 25}:: El.
	result = loop fold(arr->el:: int, {0, minInit}->state):: {idx:: int, minEl:: El}
	{
	elCur = {state["idx"], el}:: El.
	idxNext = state["idx"] + 1:: int.

	{idxNext, minEl(elCur, state["minEl"])}:: {idx:: int, minEl:: El}
	}.

	result["minEl", "idx"]
	}

	fn-minmax5 = function:: El
	{
	input = {
	{1, 72}, {3, 8}, {2, 5}, {3, 4}, {11, 1}, {6, 5}, {9, 2}
	} :: [{int, int}].

	resultInit = {0, 0}:: El.
	result = loop fold(input->el:: Pair, {0, resultInit}->acc):: {idx:: int, max:: El}
	{
	density = el[0] / el[1] :: int.
	idxNext = acc["idx"] + 1:: int.
	elCur = {acc["idx"], density}:: El.

	{idxNext, maxEl(elCur, acc["max"])}:: {idx:: int, max:: El}
	}.

	result["max"]
	}

	fn-minmax6 = function:: Pair
	{
	arr = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].

	init = {0, {{1000, 1000}, {0, 0}}}:: {int, PairEl}.

	result = loop fold(arr->val:: int, init->acc):: {int, PairEl}
	{
	el = {acc[0], val}:: El.

	idx = acc[0]+1 :: int.
	min = minEl(el, acc[1, 0]) :: El.
	max = maxLstEl(el, acc[1, 1]):: El.

	{idx, ({min, max}:: PairEl)}:: {int, PairEl}
	}.

	{result[1][0]["idx"], result[1][1]["idx"]}
	}

	fn-minmax7 = function:: Pair
	{
	arr = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].

	init = {0, {{0, 0}, {1000, 1000}}}:: {int, PairEl}.

	result = loop fold(arr->val:: int, init->acc):: {int, PairEl}
	{
	el = {acc[0], val}:: El.

	idx = acc[0]+1 :: int.
	max = maxEl(el, acc[1, 0]) :: El.
	min = minLstEl(el, acc[1, 1]):: El.

	{idx, ({max, min}:: PairEl)}:: {int, PairEl}
	}.

	{result[1][0]["idx"], result[1][1]["idx"]}
	}

	fn-minmax8 = function:: Pair
	{
	input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
	init = {0, {{1000, 1000}, {1000, 1000}}}:: {int, PairEl}.

	result = loop fold(input->val:: int, init->acc):: {int, PairEl}
	{
	el = {acc[0], val}:: El.
	idx = acc[0]+1 :: int.
	minF = minEl(el, acc[1, 0]) :: El.
	minL = minLstEl(el, acc[1, 1]):: El.

	{idx, {minF, minL}}:: {int, PairEl}
	}.

	{result[1, 0, "idx"], result[1, 1, "idx"]}
	}

	fn-minmax9 = function:: Pair
	{
	input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
	init = {0, {{0, 0}, {0, 0}}}:: {int, PairEl}.

	result = loop fold(input->val:: int, init->acc):: {int, PairEl}
	{
	el = {acc[0], val}:: El.
	idx = acc[0]+1 :: int.
	maxF = maxEl(el, acc[1, 0]) :: El.
	maxL = maxLstEl(el, acc[1, 1]):: El.

	{idx, {maxF, maxL}}:: {int, PairEl}
	}.

	{result[1, 0, "idx"], result[1, 1, "idx"]}
	}

	fn-minmax10 = function:: int
	{
	input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].
	init = {0, {{1000, 1000}, {0, 0}}}:: {int, PairEl}.

	result = loop fold(input->val:: int, init->acc):: {int, PairEl}
	{
	el = {acc[0], val}:: El.
	idx = acc[0]+1 :: int.
	minF = minEl(el, acc[1, 0]) :: El.
	maxF = maxEl(el, acc[1, 1]):: El.

	{idx, {minF, maxF}}:: {int, PairEl}
	}.

	(minElIdx(result[1, 0], result[1, 1])::El)["idx"]
	}

	fn-minmax11 = function:: int
	{
	input = {25, 37, 1, 1, 6, 5, 19, 3, 37, 20}:: [int].

	ctxInit = {0, {{1000, 1000}, {0, 0}}}:: {int, PairEl}.
	result = loop fold(input-> val:: int, ctxInit->ctx):: {int, PairEl}
	{
	elCur = {ctx[0], val}:: El.

	elMinL = minLstEl(elCur, ctx[1, 0]):: El.
	elMaxL = maxLstEl(elCur, ctx[1, 1]):: El.

	{ctx[0]+1, {elMinL, elMaxL}}:: {int, PairEl}
	}.

	(maxElIdx(result[1, 0], result[1, 1])::El)["idx"]
	}

	fn-minmax12 = function:: int
	{
	input = {-8, 16, 3, -5, 2, -11, -905, -54}:: [int].

	result = loop fold(input->val:: int, {1000, false} -> state):: {minPstv:: int, flagPstvFound:: bool}
	{
	if (val > 0):: int { {min(val, state["minPstv"]), true}:: {minPstv:: int, flagPstvFound:: bool} } else { state }
	}.

	if (result["flagPstvFound"])::int {result["minPstv"]} else { 0 }
	}

	-OptionalVal = type {flag:: bool, val:: int}.
	+

	fn-minmax13 = function::int
	{
	input = {-8, 16, 3, -5, 2, -11, -905, -54}:: [int].

	result = loop fold(input->x:: int, {false, -1000} -> state):: OptionalVal
	{
	if (x % 2 == 1):: OptionalVal {{true, max(x, state["val"])}:: OptionalVal } else { state }
	}.

	result["val"]
	}

	-OptionalEl = type {el:: El, exists:: bool}.
	-
	fn-minmax14 = function:: El
	{
	input = { -8, 16, 3, -5, 2, -11, -905, -54 }:: [int].
	threshold = 2:: int.

	result = loop fold (input -> x:: int, {0, {el = { 0, 1000 }, exists = false }} -> result):: {int , OptionalEl}
	{
	xEl = {result[0], x}:: El.

	if(x > threshold):: {int , OptionalEl}
	{
	{ result[0] + 1,
	{ el = minEl(xEl, result[1, "el"]), exists = true }
	}:: {int , OptionalEl} }
	else
	{
	result : {[0]= result[0] + 1}
	}
	}.

	if (result[1, "exists"]):: El { result[1, "el"] } else { {0, 0}:: El }
	}
	+
	+State15 = type {idx:: int, max:: OptionalEl}.
	+fn-minmax15 = function:: El
	+{
	+ input = { -8, 16, 3, -5, 2, -11, -905, -54 }:: [int].
	+ range = {2, 17}:: Pair.
	+
	+ result = loop fold(input->val::int, {0, {el = {0, 0}, exists = false}}->state):: State15
	+ {
	+ el = {state["idx"], val}:: El.
	+ stateNew = state : {idx = state["idx"] + 1}:: State15.
	+
	+ if (inRange(val, range)):: State15
	+ {
	+ stateNew : {max = ({maxEl(el, state["max", "el"]), true}:: OptionalEl)}
	+ }
	+ else
	+ {
	+ stateNew
	+ }
	+ }.
	+
	+ getOptionalEl(result["max"], {0, 0}::El)
	+}
	+
	+State19 = type {min:: int, length:: int}.
	+fn-minmax19 = function:: int
	+{
	+ input = { 18, 16, 2, 5, 2, 11, 905, 2 }:: [int].
	+
	+ result = loop fold(input->x:: int, {1000, 0}->state)::State19
	+ {
	+ if(x < state["min"]):: State19 { {x, 1}:: State19 }
	+ else
	+ {
	+ if (x == state["min"])::State19 { state: { length=state["length"] + 1 } }
	+ else { state }
	+ }
	+ }.
	+
	+ result["length"]
	+}
	+
	+State20 = type {
	+ min:: int,
	+ lenMin:: int,
	+ max:: int,
	+ lenMax:: int
	+}.
	+
	+fn-minmax20 = function:: int
	+{
	+ input = { 18, 16, 2, 5, 2, 11, 905, 2 }:: [int].
	+
	+ result = loop fold(input->x:: int, {1000, 0, 0, 0}->state)::State20
	+ {
	+ stateA = if(x < state["min"]):: State20 { state : {min = x, lenMin = 1} }
	+ else
	+ {
	+ if (x == state["min"])::State20 { state: { lenMin = state["lenMin"] + 1 } }
	+ else { state }
	+ }.
	+
	+ if(x > stateA["max"]):: State20 { stateA : {max = x, lenMax = 1} }
	+ else
	+ {
	+ if (x == state["max"])::State20 { stateA: { lenMax = stateA["lenMax"] + 1 } }
	+ else { stateA }
	+ }
	+ }.
	+
	+ result["lenMin"] + result["lenMax"]
	+}
	+
	+State21 = type {sum:: int, size:: int}.
	+fn-minmax21 = function:: int
	+{
	+ input = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}:: [int].
	+
	+ minmax = loop fold(input->x:: int, {1000, 0} ->minmax):: Pair
	+ {
	+ minmaxA = if (x < minmax[0])::Pair { minmax: {[0]=x} } else {minmax}.
	+ if (x > minmax[1])::Pair {minmaxA : {[1] = x}} else {minmaxA}
	+ }.
	+
	+ result = loop fold(input->x:: int, {0, 0}->result):: State21
	+ {
	+ if (x != minmax[0], x!= minmax[1]):: State21
	+ { {
	+ sum = result["sum"] + x,
	+ size = result["size"] + 1
	+ }:: State21} else {result}
	+ }.
	+
	+ result["sum"] / result["size"]
	+}
	+
	+min2 = function (val:: int, min:: Pair):: Pair
	+{
	+ if (val < min[0]):: Pair { {val, min[0]}::Pair }
	+ else
	+ {
	+ if(val < min[1]):: Pair { {min[0], val}::Pair }
	+ else { min }
	+ }
	+}
	+
	+fn-minmax22 = function:: Pair
	+{
	+ input = {-5, 18, 63, -29, 11, 17, 96, 28, -14}:: [int].
	+
	+ loop fold(input->x:: int, {1000, 1000}->min):: Pair
	+ {
	+ min2(x, min):: Pair
	+ }
	+}
	+
	+Triple = type {int, int, int}.
	+
	+max3 = function(x:: int, max:: Triple):: Triple
	+{
	+ if (x > max[0])::Triple { {x, max[0], max[1]}:: Triple }
	+ else
	+ {
	+ if (x > max[1]):: Triple {{max[0], x, max[1]}::Triple}
	+ else
	+ {
	+ if (x > max[2]):: Triple { max: {[2]=x} }
	+ else { max }
	+ }
	+ }
	+}
	+
	+Tuple4 = type {int, int, int, int}.
	+
	+fn-minmax23 = function:: Tuple4
	+{
	+ input = {-5, 18, 63, -29, 11, 17, 96, 28, -14}:: [int].
	+
	+ result = loop fold(input->x:: int, {-1000, -1000, -1000}->max):: Triple
	+ {
	+ max3(x, max):: Triple
	+ }.
	+
	+ {result[0], result[1], result[2], 0}
	+}

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions