YQL-20086 core

commit_hash:af5d81d51befa5cee331fbed69e7e5db2014a260

1 files changed, 230 insertions, 230 deletions

diff --git a/yql/essentials/core/yql_expr_constraint.cpp b/yql/essentials/core/yql_expr_constraint.cpp
index dede320a721..cef1fdbdf85 100644
--- a/yql/essentials/core/yql_expr_constraint.cpp
+++ b/yql/essentials/core/yql_expr_constraint.cpp
@@ -77,187 +77,187 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
 public:
     TCallableConstraintTransformer(TTypeAnnotationContext& types, bool instantOnly, bool subGraph)
         : TCallableTransformerBase<TCallableConstraintTransformer>(types, instantOnly)
-        , SubGraph(subGraph)
+        , SubGraph_(subGraph)
     {
-        Functions["FailMe"] = &TCallableConstraintTransformer::FailMe;
-        Functions["Unordered"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TUniqueConstraintNode, TDistinctConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["UnorderedSubquery"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TUniqueConstraintNode, TDistinctConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["Sort"] = &TCallableConstraintTransformer::SortWrap;
-        Functions["AssumeSorted"] = &TCallableConstraintTransformer::SortWrap;
-        Functions["AssumeUnique"] = &TCallableConstraintTransformer::AssumeUniqueWrap<false, true>;
-        Functions["AssumeDistinct"] = &TCallableConstraintTransformer::AssumeUniqueWrap<true, true>;
-        Functions["AssumeUniqueHint"] = &TCallableConstraintTransformer::AssumeUniqueWrap<false, false>;
-        Functions["AssumeDistinctHint"] = &TCallableConstraintTransformer::AssumeUniqueWrap<true, false>;
-        Functions["AssumeConstraints"] = &TCallableConstraintTransformer::AssumeConstraintsWrap;
-        Functions["AssumeChopped"] = &TCallableConstraintTransformer::AssumeChoppedWrap;
-        Functions["AssumeColumnOrder"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["AssumeAllMembersNullableAtOnce"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["Top"] = &TCallableConstraintTransformer::TopWrap<false>;
-        Functions["TopSort"] = &TCallableConstraintTransformer::TopWrap<true>;
-        Functions["TakeWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["SkipWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["TakeWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["SkipWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["WideTakeWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["WideSkipWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["WideTakeWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["WideSkipWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["Iterator"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ForwardList"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["LazyList"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["TableSource"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["WideTableSource"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ToFlow"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["FromFlow"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ToStream"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ToSequence"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["Collect"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["PruneAdjacentKeys"] = &TCallableConstraintTransformer::PruneKeysWrap<true>;
-        Functions["PruneKeys"] = &TCallableConstraintTransformer::PruneKeysWrap<false>;
-        Functions["FilterNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
-        Functions["SkipNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
-        Functions["FilterNullElements"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
-        Functions["SkipNullElements"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
-        Functions["Right!"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["Cons!"] = &TCallableConstraintTransformer::CopyAllFrom<1>;
-        Functions["ExtractMembers"] = &TCallableConstraintTransformer::ExtractMembersWrap;
-        Functions["RemoveSystemMembers"] = &TCallableConstraintTransformer::RemovePrefixMembersWrap;
-        Functions["RemovePrefixMembers"] = &TCallableConstraintTransformer::RemovePrefixMembersWrap;
-        Functions["FlattenMembers"] = &TCallableConstraintTransformer::FlattenMembersWrap;
-        Functions["SelectMembers"] = &TCallableConstraintTransformer::SelectMembersWrap;
-        Functions["FilterMembers"] = &TCallableConstraintTransformer::SelectMembersWrap;
-        Functions["CastStruct"] = &TCallableConstraintTransformer::SelectMembersWrap;
-        Functions["SafeCast"] = &TCallableConstraintTransformer::CastWrap<false>;
-        Functions["StrictCast"] = &TCallableConstraintTransformer::CastWrap<true>;
-        Functions["ToString"] = &TCallableConstraintTransformer::CastWrap<true>;
-        Functions["ToBytes"] = &TCallableConstraintTransformer::CastWrap<true>;
-        Functions["DivePrefixMembers"] = &TCallableConstraintTransformer::DivePrefixMembersWrap;
-        Functions["OrderedFilter"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["Filter"] = &TCallableConstraintTransformer::FilterWrap<false>;
-        Functions["WideFilter"] = &TCallableConstraintTransformer::FilterWrap<true>;
-        Functions["OrderedMap"] = &TCallableConstraintTransformer::MapWrap<true, false>;
-        Functions["Map"] = &TCallableConstraintTransformer::MapWrap<false, false>;
-        Functions["MapNext"] = &TCallableConstraintTransformer::MapWrap<true, false>;
-        Functions["OrderedFlatMap"] = &TCallableConstraintTransformer::MapWrap<true, true>;
-        Functions["FlatMap"] = &TCallableConstraintTransformer::MapWrap<false, true>;
-        Functions["OrderedMultiMap"] = &TCallableConstraintTransformer::MapWrap<true, false>;
-        Functions["MultiMap"] = &TCallableConstraintTransformer::MapWrap<false, false>;
-        Functions["ExpandMap"] = &TCallableConstraintTransformer::MapWrap<true, false, false, true>;
-        Functions["WideMap"] = &TCallableConstraintTransformer::MapWrap<true, false, true, true>;
-        Functions["NarrowMap"] = &TCallableConstraintTransformer::MapWrap<true, false, true, false>;
-        Functions["NarrowFlatMap"] = &TCallableConstraintTransformer::MapWrap<true, true, true, false>;
-        Functions["NarrowMultiMap"] = &TCallableConstraintTransformer::MapWrap<true, false, true, false>;
-        Functions["OrderedFlatMapToEquiJoin"] = &TCallableConstraintTransformer::MapWrap<true, true>;
-        Functions["FlatMapToEquiJoin"] = &TCallableConstraintTransformer::MapWrap<false, true>;
-        Functions["OrderedLMap"] = &TCallableConstraintTransformer::LMapWrap<true>;
-        Functions["LMap"] = &TCallableConstraintTransformer::LMapWrap<false>;
-        Functions["Extract"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode>;
-        Functions["OrderedExtract"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode>;
-        Functions["OrderedExtend"] = &TCallableConstraintTransformer::ExtendWrap<true>;
-        Functions["Extend"] = &TCallableConstraintTransformer::ExtendWrap<false>;
-        Functions["UnionAll"] = &TCallableConstraintTransformer::ExtendWrap<false>;
-        Functions["Merge"] = &TCallableConstraintTransformer::MergeWrap<false>;
-        Functions["UnionMerge"] = &TCallableConstraintTransformer::MergeWrap<true>;
-        Functions["Skip"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["Take"] = &TCallableConstraintTransformer::TakeWrap;
-        Functions["Limit"] = &TCallableConstraintTransformer::TakeWrap;
-        Functions["Member"] = &TCallableConstraintTransformer::MemberWrap;
-        Functions["AsStruct"] = &TCallableConstraintTransformer::AsStructWrap;
-        Functions["BlockAsStruct"] = &TCallableConstraintTransformer::AsStructWrap;
-        Functions["Just"] = &TCallableConstraintTransformer::FromFirst<TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfSortedConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["Unwrap"] = &TCallableConstraintTransformer::FromFirst<TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfSortedConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["Ensure"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ToList"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfSortedConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["ToOptional"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["Head"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["Last"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["Reverse"] = &TCallableConstraintTransformer::ReverseWrap;
-        Functions["Replicate"] = &TCallableConstraintTransformer::FromFirst<TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["AddMember"] = &TCallableConstraintTransformer::AddMemberWrap;
-        Functions["RemoveMember"] = &TCallableConstraintTransformer::RemoveMemberWrap;
-        Functions["ForceRemoveMember"] = &TCallableConstraintTransformer::RemoveMemberWrap;
-        Functions["ReplaceMember"] = &TCallableConstraintTransformer::ReplaceMemberWrap;
-        Functions["AsList"] = &TCallableConstraintTransformer::AsListWrap;
-        Functions["OptionalIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<false, false>;
-        Functions["FlatOptionalIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<false, true>;
-        Functions["ListIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<true, false>;
-        Functions["FlatListIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<true, true>;
-        Functions["EmptyIterator"] = &TCallableConstraintTransformer::FromEmpty;
-        Functions["EmptyFrom"] = &TCallableConstraintTransformer::EmptyFromWrap;
-        Functions["List"] = &TCallableConstraintTransformer::ListWrap;
-        Functions["Dict"] = &TCallableConstraintTransformer::DictWrap;
-        Functions["EmptyList"] = &TCallableConstraintTransformer::FromEmpty;
-        Functions["EmptyDict"] = &TCallableConstraintTransformer::FromEmpty;
-        Functions["DictFromKeys"] = &TCallableConstraintTransformer::DictFromKeysWrap;
-        Functions["If"] = &TCallableConstraintTransformer::IfWrap;
-        Functions["Nothing"] = &TCallableConstraintTransformer::FromEmpty;
-        Functions["IfPresent"] = &TCallableConstraintTransformer::IfPresentWrap;
-        Functions["Coalesce"] = &TCallableConstraintTransformer::CommonFromChildren<0, TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["CombineByKey"] = &TCallableConstraintTransformer::FromFinalLambda<TCoCombineByKey::idx_FinishHandlerLambda>;
-        Functions["FinalizeByKey"] = &TCallableConstraintTransformer::FromFinalLambda<TCoFinalizeByKey::idx_FinishHandlerLambda>;
-        Functions["CombineCore"] = &TCallableConstraintTransformer::FromFinalLambda<TCoCombineCore::idx_FinishHandler>;
-        Functions["PartitionByKey"] = &TCallableConstraintTransformer::ShuffleByKeysWrap<true>;
-        Functions["PartitionsByKeys"] = &TCallableConstraintTransformer::ShuffleByKeysWrap<true>;
-        Functions["ShuffleByKeys"] = &TCallableConstraintTransformer::ShuffleByKeysWrap<false>;
-        Functions["Switch"] = &TCallableConstraintTransformer::SwitchWrap;
-        Functions["Visit"] = &TCallableConstraintTransformer::VisitWrap;
-        Functions["VariantItem"] = &TCallableConstraintTransformer::VariantItemWrap;
-        Functions["Variant"] = &TCallableConstraintTransformer::VariantWrap;
-        Functions["DynamicVariant"] = &TCallableConstraintTransformer::DynamicVariantWrap;
-        Functions["Guess"] = &TCallableConstraintTransformer::GuessWrap;
-        Functions["Mux"] = &TCallableConstraintTransformer::MuxWrap;
-        Functions["Nth"] = &TCallableConstraintTransformer::NthWrap;
-        Functions["EquiJoin"] = &TCallableConstraintTransformer::EquiJoinWrap;
-        Functions["JoinDict"] = &TCallableConstraintTransformer::JoinDictWrap;
-        Functions["MapJoinCore"] = &TCallableConstraintTransformer::MapJoinCoreWrap;
-        Functions["GraceJoinCore"] = &TCallableConstraintTransformer::GraceJoinCoreWrap;
-        Functions["GraceSelfJoinCore"] = &TCallableConstraintTransformer::GraceSelfJoinCoreWrap;
-        Functions["CommonJoinCore"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode>;
-        Functions["ToDict"] = &TCallableConstraintTransformer::ToDictWrap;
-        Functions["DictItems"] = &TCallableConstraintTransformer::DictItemsWrap;
-        Functions["DictKeys"] = &TCallableConstraintTransformer::DictHalfWrap<true>;
-        Functions["DictPayloads"] = &TCallableConstraintTransformer::DictHalfWrap<false>;
-        Functions["Chain1Map"] = &TCallableConstraintTransformer::Chain1MapWrap<false>;
-        Functions["WideChain1Map"] = &TCallableConstraintTransformer::Chain1MapWrap<true>;
-        Functions["IsKeySwitch"] = &TCallableConstraintTransformer::IsKeySwitchWrap;
-        Functions["Condense"] = &TCallableConstraintTransformer::CondenseWrap;
-        Functions["Condense1"] = &TCallableConstraintTransformer::Condense1Wrap<false>;
-        Functions["GroupingCore"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
-        Functions["Chopper"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
-        Functions["WideChopper"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
-        Functions["WideCombiner"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
-        Functions["WideCondense1"] = &TCallableConstraintTransformer::Condense1Wrap<true>;
-        Functions["Aggregate"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["AggregateMergeState"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["AggregateMergeFinalize"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["AggregateMergeManyFinalize"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["AggregateFinalize"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["AggregateCombine"] = &TCallableConstraintTransformer::AggregateWrap<false>;
-        Functions["AggregateCombineState"] = &TCallableConstraintTransformer::AggregateWrap<false>;
-        Functions["Fold"] = &TCallableConstraintTransformer::FoldWrap;
-        Functions["Fold1"] = &TCallableConstraintTransformer::FoldWrap;
-        Functions["WithContext"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["WithWorld"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["WideTop"] = &TCallableConstraintTransformer::WideTopWrap<false>;
-        Functions["WideTopSort"] = &TCallableConstraintTransformer::WideTopWrap<true>;
-        Functions["WideSort"] = &TCallableConstraintTransformer::WideTopWrap<true>;
-        Functions["WideTopBlocks"] = &TCallableConstraintTransformer::WideTopWrap<false>;
-        Functions["WideTopSortBlocks"] = &TCallableConstraintTransformer::WideTopWrap<true>;
-        Functions["WideSortBlocks"] = &TCallableConstraintTransformer::WideTopWrap<true>;
-        Functions["WideToBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ListToBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["WideFromBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ListFromBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["ReplicateScalars"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["BlockMergeFinalizeHashed"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["BlockMergeManyFinalizeHashed"] = &TCallableConstraintTransformer::AggregateWrap<true>;
-        Functions["MultiHoppingCore"] = &TCallableConstraintTransformer::MultiHoppingCoreWrap;
-        Functions["StablePickle"] = &TCallableConstraintTransformer::PickleWrap;
-        Functions["Unpickle"] = &TCallableConstraintTransformer::FromSecond<TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode>;
+        Functions_["FailMe"] = &TCallableConstraintTransformer::FailMe;
+        Functions_["Unordered"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TUniqueConstraintNode, TDistinctConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["UnorderedSubquery"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TUniqueConstraintNode, TDistinctConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["Sort"] = &TCallableConstraintTransformer::SortWrap;
+        Functions_["AssumeSorted"] = &TCallableConstraintTransformer::SortWrap;
+        Functions_["AssumeUnique"] = &TCallableConstraintTransformer::AssumeUniqueWrap<false, true>;
+        Functions_["AssumeDistinct"] = &TCallableConstraintTransformer::AssumeUniqueWrap<true, true>;
+        Functions_["AssumeUniqueHint"] = &TCallableConstraintTransformer::AssumeUniqueWrap<false, false>;
+        Functions_["AssumeDistinctHint"] = &TCallableConstraintTransformer::AssumeUniqueWrap<true, false>;
+        Functions_["AssumeConstraints"] = &TCallableConstraintTransformer::AssumeConstraintsWrap;
+        Functions_["AssumeChopped"] = &TCallableConstraintTransformer::AssumeChoppedWrap;
+        Functions_["AssumeColumnOrder"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["AssumeAllMembersNullableAtOnce"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["Top"] = &TCallableConstraintTransformer::TopWrap<false>;
+        Functions_["TopSort"] = &TCallableConstraintTransformer::TopWrap<true>;
+        Functions_["TakeWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["SkipWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["TakeWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["SkipWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["WideTakeWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["WideSkipWhile"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["WideTakeWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["WideSkipWhileInclusive"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["Iterator"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ForwardList"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["LazyList"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["TableSource"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["WideTableSource"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ToFlow"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["FromFlow"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ToStream"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ToSequence"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["Collect"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["PruneAdjacentKeys"] = &TCallableConstraintTransformer::PruneKeysWrap<true>;
+        Functions_["PruneKeys"] = &TCallableConstraintTransformer::PruneKeysWrap<false>;
+        Functions_["FilterNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
+        Functions_["SkipNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
+        Functions_["FilterNullElements"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
+        Functions_["SkipNullElements"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode>;
+        Functions_["Right!"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["Cons!"] = &TCallableConstraintTransformer::CopyAllFrom<1>;
+        Functions_["ExtractMembers"] = &TCallableConstraintTransformer::ExtractMembersWrap;
+        Functions_["RemoveSystemMembers"] = &TCallableConstraintTransformer::RemovePrefixMembersWrap;
+        Functions_["RemovePrefixMembers"] = &TCallableConstraintTransformer::RemovePrefixMembersWrap;
+        Functions_["FlattenMembers"] = &TCallableConstraintTransformer::FlattenMembersWrap;
+        Functions_["SelectMembers"] = &TCallableConstraintTransformer::SelectMembersWrap;
+        Functions_["FilterMembers"] = &TCallableConstraintTransformer::SelectMembersWrap;
+        Functions_["CastStruct"] = &TCallableConstraintTransformer::SelectMembersWrap;
+        Functions_["SafeCast"] = &TCallableConstraintTransformer::CastWrap<false>;
+        Functions_["StrictCast"] = &TCallableConstraintTransformer::CastWrap<true>;
+        Functions_["ToString"] = &TCallableConstraintTransformer::CastWrap<true>;
+        Functions_["ToBytes"] = &TCallableConstraintTransformer::CastWrap<true>;
+        Functions_["DivePrefixMembers"] = &TCallableConstraintTransformer::DivePrefixMembersWrap;
+        Functions_["OrderedFilter"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["Filter"] = &TCallableConstraintTransformer::FilterWrap<false>;
+        Functions_["WideFilter"] = &TCallableConstraintTransformer::FilterWrap<true>;
+        Functions_["OrderedMap"] = &TCallableConstraintTransformer::MapWrap<true, false>;
+        Functions_["Map"] = &TCallableConstraintTransformer::MapWrap<false, false>;
+        Functions_["MapNext"] = &TCallableConstraintTransformer::MapWrap<true, false>;
+        Functions_["OrderedFlatMap"] = &TCallableConstraintTransformer::MapWrap<true, true>;
+        Functions_["FlatMap"] = &TCallableConstraintTransformer::MapWrap<false, true>;
+        Functions_["OrderedMultiMap"] = &TCallableConstraintTransformer::MapWrap<true, false>;
+        Functions_["MultiMap"] = &TCallableConstraintTransformer::MapWrap<false, false>;
+        Functions_["ExpandMap"] = &TCallableConstraintTransformer::MapWrap<true, false, false, true>;
+        Functions_["WideMap"] = &TCallableConstraintTransformer::MapWrap<true, false, true, true>;
+        Functions_["NarrowMap"] = &TCallableConstraintTransformer::MapWrap<true, false, true, false>;
+        Functions_["NarrowFlatMap"] = &TCallableConstraintTransformer::MapWrap<true, true, true, false>;
+        Functions_["NarrowMultiMap"] = &TCallableConstraintTransformer::MapWrap<true, false, true, false>;
+        Functions_["OrderedFlatMapToEquiJoin"] = &TCallableConstraintTransformer::MapWrap<true, true>;
+        Functions_["FlatMapToEquiJoin"] = &TCallableConstraintTransformer::MapWrap<false, true>;
+        Functions_["OrderedLMap"] = &TCallableConstraintTransformer::LMapWrap<true>;
+        Functions_["LMap"] = &TCallableConstraintTransformer::LMapWrap<false>;
+        Functions_["Extract"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode>;
+        Functions_["OrderedExtract"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode>;
+        Functions_["OrderedExtend"] = &TCallableConstraintTransformer::ExtendWrap<true>;
+        Functions_["Extend"] = &TCallableConstraintTransformer::ExtendWrap<false>;
+        Functions_["UnionAll"] = &TCallableConstraintTransformer::ExtendWrap<false>;
+        Functions_["Merge"] = &TCallableConstraintTransformer::MergeWrap<false>;
+        Functions_["UnionMerge"] = &TCallableConstraintTransformer::MergeWrap<true>;
+        Functions_["Skip"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["Take"] = &TCallableConstraintTransformer::TakeWrap;
+        Functions_["Limit"] = &TCallableConstraintTransformer::TakeWrap;
+        Functions_["Member"] = &TCallableConstraintTransformer::MemberWrap;
+        Functions_["AsStruct"] = &TCallableConstraintTransformer::AsStructWrap;
+        Functions_["BlockAsStruct"] = &TCallableConstraintTransformer::AsStructWrap;
+        Functions_["Just"] = &TCallableConstraintTransformer::FromFirst<TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfSortedConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["Unwrap"] = &TCallableConstraintTransformer::FromFirst<TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfSortedConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["Ensure"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ToList"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfSortedConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["ToOptional"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["Head"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["Last"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["Reverse"] = &TCallableConstraintTransformer::ReverseWrap;
+        Functions_["Replicate"] = &TCallableConstraintTransformer::FromFirst<TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["AddMember"] = &TCallableConstraintTransformer::AddMemberWrap;
+        Functions_["RemoveMember"] = &TCallableConstraintTransformer::RemoveMemberWrap;
+        Functions_["ForceRemoveMember"] = &TCallableConstraintTransformer::RemoveMemberWrap;
+        Functions_["ReplaceMember"] = &TCallableConstraintTransformer::ReplaceMemberWrap;
+        Functions_["AsList"] = &TCallableConstraintTransformer::AsListWrap;
+        Functions_["OptionalIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<false, false>;
+        Functions_["FlatOptionalIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<false, true>;
+        Functions_["ListIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<true, false>;
+        Functions_["FlatListIf"] = &TCallableConstraintTransformer::PassOrEmptyWrap<true, true>;
+        Functions_["EmptyIterator"] = &TCallableConstraintTransformer::FromEmpty;
+        Functions_["EmptyFrom"] = &TCallableConstraintTransformer::EmptyFromWrap;
+        Functions_["List"] = &TCallableConstraintTransformer::ListWrap;
+        Functions_["Dict"] = &TCallableConstraintTransformer::DictWrap;
+        Functions_["EmptyList"] = &TCallableConstraintTransformer::FromEmpty;
+        Functions_["EmptyDict"] = &TCallableConstraintTransformer::FromEmpty;
+        Functions_["DictFromKeys"] = &TCallableConstraintTransformer::DictFromKeysWrap;
+        Functions_["If"] = &TCallableConstraintTransformer::IfWrap;
+        Functions_["Nothing"] = &TCallableConstraintTransformer::FromEmpty;
+        Functions_["IfPresent"] = &TCallableConstraintTransformer::IfPresentWrap;
+        Functions_["Coalesce"] = &TCallableConstraintTransformer::CommonFromChildren<0, TSortedConstraintNode, TPartOfSortedConstraintNode, TChoppedConstraintNode, TPartOfChoppedConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions_["CombineByKey"] = &TCallableConstraintTransformer::FromFinalLambda<TCoCombineByKey::idx_FinishHandlerLambda>;
+        Functions_["FinalizeByKey"] = &TCallableConstraintTransformer::FromFinalLambda<TCoFinalizeByKey::idx_FinishHandlerLambda>;
+        Functions_["CombineCore"] = &TCallableConstraintTransformer::FromFinalLambda<TCoCombineCore::idx_FinishHandler>;
+        Functions_["PartitionByKey"] = &TCallableConstraintTransformer::ShuffleByKeysWrap<true>;
+        Functions_["PartitionsByKeys"] = &TCallableConstraintTransformer::ShuffleByKeysWrap<true>;
+        Functions_["ShuffleByKeys"] = &TCallableConstraintTransformer::ShuffleByKeysWrap<false>;
+        Functions_["Switch"] = &TCallableConstraintTransformer::SwitchWrap;
+        Functions_["Visit"] = &TCallableConstraintTransformer::VisitWrap;
+        Functions_["VariantItem"] = &TCallableConstraintTransformer::VariantItemWrap;
+        Functions_["Variant"] = &TCallableConstraintTransformer::VariantWrap;
+        Functions_["DynamicVariant"] = &TCallableConstraintTransformer::DynamicVariantWrap;
+        Functions_["Guess"] = &TCallableConstraintTransformer::GuessWrap;
+        Functions_["Mux"] = &TCallableConstraintTransformer::MuxWrap;
+        Functions_["Nth"] = &TCallableConstraintTransformer::NthWrap;
+        Functions_["EquiJoin"] = &TCallableConstraintTransformer::EquiJoinWrap;
+        Functions_["JoinDict"] = &TCallableConstraintTransformer::JoinDictWrap;
+        Functions_["MapJoinCore"] = &TCallableConstraintTransformer::MapJoinCoreWrap;
+        Functions_["GraceJoinCore"] = &TCallableConstraintTransformer::GraceJoinCoreWrap;
+        Functions_["GraceSelfJoinCore"] = &TCallableConstraintTransformer::GraceSelfJoinCoreWrap;
+        Functions_["CommonJoinCore"] = &TCallableConstraintTransformer::FromFirst<TEmptyConstraintNode>;
+        Functions_["ToDict"] = &TCallableConstraintTransformer::ToDictWrap;
+        Functions_["DictItems"] = &TCallableConstraintTransformer::DictItemsWrap;
+        Functions_["DictKeys"] = &TCallableConstraintTransformer::DictHalfWrap<true>;
+        Functions_["DictPayloads"] = &TCallableConstraintTransformer::DictHalfWrap<false>;
+        Functions_["Chain1Map"] = &TCallableConstraintTransformer::Chain1MapWrap<false>;
+        Functions_["WideChain1Map"] = &TCallableConstraintTransformer::Chain1MapWrap<true>;
+        Functions_["IsKeySwitch"] = &TCallableConstraintTransformer::IsKeySwitchWrap;
+        Functions_["Condense"] = &TCallableConstraintTransformer::CondenseWrap;
+        Functions_["Condense1"] = &TCallableConstraintTransformer::Condense1Wrap<false>;
+        Functions_["GroupingCore"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
+        Functions_["Chopper"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
+        Functions_["WideChopper"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
+        Functions_["WideCombiner"] = &TCallableConstraintTransformer::InheriteEmptyFromInput;
+        Functions_["WideCondense1"] = &TCallableConstraintTransformer::Condense1Wrap<true>;
+        Functions_["Aggregate"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["AggregateMergeState"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["AggregateMergeFinalize"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["AggregateMergeManyFinalize"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["AggregateFinalize"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["AggregateCombine"] = &TCallableConstraintTransformer::AggregateWrap<false>;
+        Functions_["AggregateCombineState"] = &TCallableConstraintTransformer::AggregateWrap<false>;
+        Functions_["Fold"] = &TCallableConstraintTransformer::FoldWrap;
+        Functions_["Fold1"] = &TCallableConstraintTransformer::FoldWrap;
+        Functions_["WithContext"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["WithWorld"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["WideTop"] = &TCallableConstraintTransformer::WideTopWrap<false>;
+        Functions_["WideTopSort"] = &TCallableConstraintTransformer::WideTopWrap<true>;
+        Functions_["WideSort"] = &TCallableConstraintTransformer::WideTopWrap<true>;
+        Functions_["WideTopBlocks"] = &TCallableConstraintTransformer::WideTopWrap<false>;
+        Functions_["WideTopSortBlocks"] = &TCallableConstraintTransformer::WideTopWrap<true>;
+        Functions_["WideSortBlocks"] = &TCallableConstraintTransformer::WideTopWrap<true>;
+        Functions_["WideToBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ListToBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["WideFromBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ListFromBlocks"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["ReplicateScalars"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
+        Functions_["BlockMergeFinalizeHashed"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["BlockMergeManyFinalizeHashed"] = &TCallableConstraintTransformer::AggregateWrap<true>;
+        Functions_["MultiHoppingCore"] = &TCallableConstraintTransformer::MultiHoppingCoreWrap;
+        Functions_["StablePickle"] = &TCallableConstraintTransformer::PickleWrap;
+        Functions_["Unpickle"] = &TCallableConstraintTransformer::FromSecond<TUniqueConstraintNode, TPartOfUniqueConstraintNode, TDistinctConstraintNode, TPartOfDistinctConstraintNode, TPartOfChoppedConstraintNode, TVarIndexConstraintNode>;
     }
 
     std::optional<IGraphTransformer::TStatus> ProcessCore(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) {
-        if (const auto func = Functions.find(input->Content()); Functions.cend() != func) {
+        if (const auto func = Functions_.find(input->Content()); Functions_.cend() != func) {
             return (this->*func->second)(input, output, ctx);
         }
         return std::nullopt;
@@ -290,7 +290,7 @@ public:
     }
 
     IGraphTransformer& GetTransformer(IDataProvider& provider) const {
-        return provider.GetConstraintTransformer(InstantOnly, SubGraph);
+        return provider.GetConstraintTransformer(InstantOnly_, SubGraph_);
     }
 
 private:
@@ -3171,8 +3171,8 @@ private:
         return valueNode;
     }
 private:
-    const bool SubGraph;
-    std::unordered_map<std::string_view, THandler> Functions;
+    const bool SubGraph_;
+    std::unordered_map<std::string_view, THandler> Functions_;
 };
 
 template<> const TPartOfSortedConstraintNode*
@@ -3268,8 +3268,8 @@ template<bool DisableCheck>
 class TConstraintTransformer : public TGraphTransformerBase {
 public:
     TConstraintTransformer(TAutoPtr<IGraphTransformer> callableTransformer, TTypeAnnotationContext& types)
-        : CallableTransformer(callableTransformer)
-        , Types(types)
+        : CallableTransformer_(callableTransformer)
+        , Types_(types)
     {
     }
 
@@ -3281,16 +3281,16 @@ public:
         auto status = TransformNode(input, output, ctx);
         UpdateStatusIfChanged(status, input, output);
 
-        if (status.Level != TStatus::Error && HasRenames) {
-            output = ctx.ReplaceNodes(std::move(output), Processed);
+        if (status.Level != TStatus::Error && HasRenames_) {
+            output = ctx.ReplaceNodes(std::move(output), Processed_);
         }
 
-        Processed.clear();
+        Processed_.clear();
         if (status == TStatus::Ok) {
-            Types.ExpectedConstraints.clear();
+            Types_.ExpectedConstraints.clear();
         }
 
-        HasRenames = false;
+        HasRenames_ = false;
         return status;
     }
 
@@ -3298,8 +3298,8 @@ public:
         YQL_PROFILE_SCOPE(DEBUG, "ConstraintTransformer::DoGetAsyncFuture");
         Y_UNUSED(input);
         TVector<NThreading::TFuture<void>> futures;
-        for (const auto& callable : CallableInputs) {
-            futures.push_back(CallableTransformer->GetAsyncFuture(*callable));
+        for (const auto& callable : CallableInputs_) {
+            futures.push_back(CallableTransformer_->GetAsyncFuture(*callable));
         }
 
         return WaitExceptionOrAll(futures);
@@ -3309,10 +3309,10 @@ public:
         YQL_PROFILE_SCOPE(DEBUG, "ConstraintTransformer::DoApplyAsyncChanges");
         output = input;
         TStatus combinedStatus = TStatus::Ok;
-        for (const auto& callable : CallableInputs) {
+        for (const auto& callable : CallableInputs_) {
             callable->SetState(TExprNode::EState::ConstrPending);
             TExprNode::TPtr callableOutput;
-            auto status = CallableTransformer->ApplyAsyncChanges(callable, callableOutput, ctx);
+            auto status = CallableTransformer_->ApplyAsyncChanges(callable, callableOutput, ctx);
             Y_ABORT_UNLESS(callableOutput);
             YQL_ENSURE(status != TStatus::Async);
             YQL_ENSURE(callableOutput == callable);
@@ -3322,26 +3322,26 @@ public:
             }
         }
 
-        CallableInputs.clear();
+        CallableInputs_.clear();
         if (combinedStatus.Level == TStatus::Ok) {
-            Processed.clear();
+            Processed_.clear();
         }
 
         return combinedStatus;
     }
 
     void Rewind() final {
-        CallableTransformer->Rewind();
-        CallableInputs.clear();
-        Processed.clear();
-        HasRenames = false;
-        CurrentFunctions = {};
+        CallableTransformer_->Rewind();
+        CallableInputs_.clear();
+        Processed_.clear();
+        HasRenames_ = false;
+        CurrentFunctions_ = {};
     }
 
 private:
     TStatus TransformNode(const TExprNode::TPtr& start, TExprNode::TPtr& output, TExprContext& ctx) {
         output = start;
-        auto processedPair = Processed.emplace(start.Get(), nullptr); // by default node is not changed
+        auto processedPair = Processed_.emplace(start.Get(), nullptr); // by default node is not changed
         if (!processedPair.second) {
             if (processedPair.first->second) {
                 output = processedPair.first->second;
@@ -3391,32 +3391,32 @@ private:
                 str << "At ";
                 switch (input->Type()) {
                 case TExprNode::Callable:
-                    if (!CurrentFunctions.empty() && CurrentFunctions.top().second) {
+                    if (!CurrentFunctions_.empty() && CurrentFunctions_.top().second) {
                         return nullptr;
                     }
 
-                    if (!CurrentFunctions.empty()) {
-                        CurrentFunctions.top().second = true;
+                    if (!CurrentFunctions_.empty()) {
+                        CurrentFunctions_.top().second = true;
                     }
 
                     str << "function: " << input->Content();
                     break;
                 case TExprNode::List:
-                    if (CurrentFunctions.empty()) {
+                    if (CurrentFunctions_.empty()) {
                         str << "tuple";
-                    } else if (!CurrentFunctions.top().second) {
-                        CurrentFunctions.top().second = true;
-                        str << "function: " << CurrentFunctions.top().first;
+                    } else if (!CurrentFunctions_.top().second) {
+                        CurrentFunctions_.top().second = true;
+                        str << "function: " << CurrentFunctions_.top().first;
                     } else {
                         return nullptr;
                     }
                     break;
                 case TExprNode::Lambda:
-                    if (CurrentFunctions.empty()) {
+                    if (CurrentFunctions_.empty()) {
                         str << "lambda";
-                    } else if (!CurrentFunctions.top().second) {
-                        CurrentFunctions.top().second = true;
-                        str << "function: " << CurrentFunctions.top().first;
+                    } else if (!CurrentFunctions_.top().second) {
+                        CurrentFunctions_.top().second = true;
+                        str << "function: " << CurrentFunctions_.top().first;
                     } else {
                         return nullptr;
                     }
@@ -3429,13 +3429,13 @@ private:
             });
 
             if (input->IsCallable()) {
-                CurrentFunctions.emplace(input->Content(), false);
+                CurrentFunctions_.emplace(input->Content(), false);
             }
             Y_SCOPE_EXIT(this, input) {
                 if (input->IsCallable()) {
-                    CurrentFunctions.pop();
-                    if (!CurrentFunctions.empty() && CurrentFunctions.top().first.ends_with('!')) {
-                        CurrentFunctions.top().second = true;
+                    CurrentFunctions_.pop();
+                    if (!CurrentFunctions_.empty() && CurrentFunctions_.top().first.ends_with('!')) {
+                        CurrentFunctions_.top().second = true;
                     }
                 }
             };
@@ -3475,7 +3475,7 @@ private:
             {
                 retStatus = TransformChildren(input, output, ctx);
                 if (retStatus == TStatus::Ok) {
-                    retStatus = CallableTransformer->Transform(input, output, ctx);
+                    retStatus = CallableTransformer_->Transform(input, output, ctx);
                     if (retStatus == TStatus::Ok) {
                         input->SetState(TExprNode::EState::ConstrComplete);
                         CheckExpected(*input);
@@ -3525,7 +3525,7 @@ private:
                     else if (updatedChildren) {
                         output = ctx.DeepCopyLambda(*input, std::move(newBody));
                         processedPair.first->second = output;
-                        HasRenames = true;
+                        HasRenames_ = true;
                     }
                 } else {
                     if (input->ChildrenSize() != 2U)
@@ -3582,8 +3582,8 @@ private:
                     break;
                 }
 
-                CurrentFunctions.top().second = true;
-                retStatus = CallableTransformer->Transform(input, output, ctx);
+                CurrentFunctions_.top().second = true;
+                retStatus = CallableTransformer_->Transform(input, output, ctx);
                 if (retStatus == TStatus::Error) {
                     input->SetState(TExprNode::EState::Error);
                 } else if (retStatus == TStatus::Ok) {
@@ -3595,12 +3595,12 @@ private:
                     input->SetState(TExprNode::EState::ConstrComplete);
                     CheckExpected(*input);
                 } else if (retStatus == TStatus::Async) {
-                    CallableInputs.push_back(input);
+                    CallableInputs_.push_back(input);
                     input->SetState(TExprNode::EState::ConstrInProgress);
                 } else {
                     if (output != input.Get()) {
                         processedPair.first->second = output;
-                        HasRenames = true;
+                        HasRenames_ = true;
                     }
                 }
                 break;
@@ -3637,7 +3637,7 @@ private:
             }
             else if (updatedChildren) {
                 output = ctx.ChangeChildren(*input, std::move(newChildren));
-                HasRenames = true;
+                HasRenames_ = true;
             }
         }
         return combinedStatus;
@@ -3653,12 +3653,12 @@ private:
         if constexpr (DisableCheck)
             return;
 
-        if (const auto it = Types.ExpectedConstraints.find(input.UniqueId()); it != Types.ExpectedConstraints.cend()) {
+        if (const auto it = Types_.ExpectedConstraints.find(input.UniqueId()); it != Types_.ExpectedConstraints.cend()) {
             for (const auto expectedConstr: it->second) {
-                if (!Types.DisableConstraintCheck.contains(expectedConstr->GetName())) {
+                if (!Types_.DisableConstraintCheck.contains(expectedConstr->GetName())) {
                     if (auto newConstr = input.GetConstraint(expectedConstr->GetName())) {
                         if (expectedConstr->GetName() == TMultiConstraintNode::Name()) {
-                            YQL_ENSURE(static_cast<const TMultiConstraintNode*>(newConstr)->FilteredIncludes(*expectedConstr, Types.DisableConstraintCheck), "Rewrite error, unequal " << *newConstr
+                            YQL_ENSURE(static_cast<const TMultiConstraintNode*>(newConstr)->FilteredIncludes(*expectedConstr, Types_.DisableConstraintCheck), "Rewrite error, unequal " << *newConstr
                                 << " constraint in node " << input.Content() << ", previous was " << *expectedConstr);
                         } else {
                             YQL_ENSURE(newConstr->Includes(*expectedConstr), "Rewrite error, unequal " << *newConstr
@@ -3676,12 +3676,12 @@ private:
         }
     }
 private:
-    TAutoPtr<IGraphTransformer> CallableTransformer;
-    std::deque<TExprNode::TPtr> CallableInputs;
-    TNodeOnNodeOwnedMap Processed;
-    bool HasRenames = false;
-    std::stack<std::pair<std::string_view, bool>> CurrentFunctions;
-    TTypeAnnotationContext& Types;
+    TAutoPtr<IGraphTransformer> CallableTransformer_;
+    std::deque<TExprNode::TPtr> CallableInputs_;
+    TNodeOnNodeOwnedMap Processed_;
+    bool HasRenames_ = false;
+    std::stack<std::pair<std::string_view, bool>> CurrentFunctions_;
+    TTypeAnnotationContext& Types_;
 };
 
 } // namespace