Tuple<Column, Column> aaaa = new Tuple<Column, Column>(xxxx, yyyy);
aaaa.Val1 ...;
aaaa.Val2 ...;

ПК>А Саттер-то тут причем?

ПК> Да и в C++ tuples вполне реализуются на уровне библиотек...

tuple<int>
tuple<double&, const double&, const double, double*, const double*>
tuple<A, int(*)(char, int), B(A::*)(C&), C>
tuple<std::string, std::pair<A, B> >
tuple<A*, tuple<const A*, const B&, C>, bool, void*>

VD>tuple<int>
VD>tuple<double&, const double&, const double, double*, const double*>
VD>tuple<A, int(*)(char, int), B(A::*)(C&), C>
VD>tuple<std::string, std::pair<A, B> >
VD>tuple<A*, tuple<const A*, const B&, C>, bool, void*>
VD>

int i = get<0>(t); i = t.get<0>();        // ok
int j = get<0>(ct);                       // ok
get<0>(t) = 5;                            // ok 
get<0>(ct) = 5;                           // error, can't assign to const 
  ...
double e = get<1>(t); // ok   
get<1>(t) = 3.14;     // ok 
get<2>(t) = A();      // error, can't assign to const 
A aa = get<3>(t);     // error: index out of bounds

// Формируем строку формата "str" и список аргуменов (выражений в них подсавляемых).
def (str, args, _) = exprs.FoldRight(("", [], 0), fun(expr, accumulator)
{
    // Выделяем из кортежа отдельные значения
    // str - формируемая строка форамата.
    // args - формируемый список выражений параметров.
    // i - счетчик количества параметров.
    def (str, args, i) = accumulator;
    def x = expr.ToString(); // Преобразуем текущее выражение в строку.
    // Функция Unquot(s) убирает обрамляющие ковычки из строки.
    def Unquot(s) { s.Substring(1).Substring(0, s.Length - 2) }
    // AddTwiceBraces(s) удваиват знаки "{" и "}".
    def AddTwiceBraces(s) { s.Replace("{", "{{").Replace("}", "}}") }
    
    if (x.Length > 0)
    {
        // Если стока начинается с ", то это просто подстрока которую нужно 
        // обработать и добавить в строку формата.
        if (x[0] == '"')
            (str + AddTwiceBraces(Unquot(x)), args, i)
        // иначе это "встроеное" подвыражение выделенное из строки.
        // Для каждого такого подвыражения нужно добавить с форматную строку
        // тег вида {x} где x - это номер подвыражения, а так же добавить выражение 
        // в список выражений которые в посделствии будут формировать параметры.
        else
            (str + "{" + i.ToString() + "}", expr :: args, i + 1)
    }
    else // Если строка пуста, то ничего не делаем.
        accumulator
});

F(1, "text", 1.2);

def tuple1 = (1, "text", 1.2);
F(tuple1);

>> int i = get<0>(t); i = t.get<0>();        // ok
>> int j = get<0>(ct);                       // ok
>> get<0>(t) = 5;                            // ok
>> get<0>(ct) = 5;                           // error, can't assign to const
>>   ...
>> double e = get<1>(t); // ok
>> get<1>(t) = 3.14;     // ok
>> get<2>(t) = A();      // error, can't assign to const
>> A aa = get<3>(t);     // error: index out of bounds
>>

int i = get<0>(t);

def (i, _) = t;

i = t.get<0>();        // ok

(1, "ss")

var t = new (IntValue = 1, DoubleValue = 12.75, AValue = new A());
var t2 = new (2, 17.75, new A("A"));
int i = t.IntValue;
double d = t.DoubleValue;
A a = t2.AValue;
t2 = t1;

> var t = new (IntValue = 1, DoubleValue = 12.75, AValue = new A());
> var t2 = new (2, 17.75, new A("A"));
>

auto t  = make_tuple(1, 12.75, A());
auto t2 = make_tuple(2, 17.75, A("A"));

> int i = t.IntValue;
> double d = t.DoubleValue;
> A a = t2.AValue;
> t2 = t1;
>

int    i = get<0>( t );
double d = get<1>( t );
A      a = get<2>( t2 );

> int i = get<0>(t);
>

> def (i, _) = t;
>

int i;
tie(i, ignore) = t;

> i = t.get<0>();        // ok
>

i = get<0>( t );

> (1, "ss")
>

> F(1, "text", 1.2);
>

> def tuple1 = (1, "text", 1.2);
> F(tuple1);
>

auto tuple1 = make_tuple(1, "text", 1.2);
call(&F, tuple1);

ПК>>int    i = get<0>( t );
ПК>>double d = get<1>( t );
ПК>>A      a = get<2>( t2 );
ПК>>

// Классика жанра:
// двоичный поиск в сортированном массиве
// возвращаем пару <найдено,индекс>
template <class Array, class T> pair<bool, int>
    bin_search(const Array &array, const T &key);

void test()
{
   bool  ok;
   int   pos;
   
// кортеж из функции сразу распаковываем, юзая функцию tie
// tie(...) { return Tie<>(...); } где Tie - хелпер-класс распаковки кортежей
   tie(ok, pos) = bin_search(some_array, some_key);
   if (ok) // понеслась
      work_with(some_array[pos]);
}

>> var t = new (IntValue = 1, DoubleValue = 12.75, AValue = new A());
>> var t2 = new (2, 17.75, new A("A"));
>>

ПК>auto t  = make_tuple(1, 12.75, A());
ПК>auto t2 = make_tuple(2, 17.75, A("A"));
ПК>

>> int i = t.IntValue;
>> double d = t.DoubleValue;
>> A a = t2.AValue;
>> t2 = t1;
>>

var t = new {IntValue = 1, DoubleValue = 12.75, AValue = new A()};
int IntValue = 2; double DoubleValue = 12.75; A AValue = new A("A");
var t2 = new {IntValue, DoubleValue, AValue};

// idx - номер сегмента
// t   - в какую точку на сегменте проецируется pt [0, 1]
// dist- растояние от pt к сегменту. 
void closest_segment(const Point3d &pt, int &idx, double &t, double &dist);

// к примеру нужен только индекс и расстояние
int idx;
double dst;
tie(idx, _, dst) = pline.closest_segment(pt_from); // t пропускаем

closest_segment(pt_from, idx, unused, dist);

closest_segment(pt_from, idx, unused, dist);

struct Unused
{
    template <class T>
        operator T& ()
    {
        static T dummy;
        return dummy;
    }
};

extern Unused unused;

//=================================================

void foo(int &x, double &y, string &s);

void test()
{
   int x;
   double y;
   string s;

   foo(x, y, s); // беру все
   foo(unused, y, s); // почти все
   foo(unused, unused, s); // мне много не надо
}

using ElemTuple = Tuple<int, List<int>, int[]>;

...

private void ReadContent(ReadContext context)
{
    Stack<ElemTuple> elemsStack = new Stack<ElemTuple>();
    XmlReader rdr = context.Reader;
    while (rdr.Read())
        switch (rdr.NodeType)
        {
            case XmlNodeType.Element :
                int en = context.AddString(rdr.Name);
                int[] attrs = ReadAttrs(context);
                if (rdr.IsEmptyElement)
                {
                    int eei = context.AddElement(new ElementStruct(this, en, EmptyInts, attrs));
                    if (elemsStack.Count > 0)
                        elemsStack.Peek().V2.Add(eei);
                }
                else
                    elemsStack.Push(new ElemTuple(en, new List<int>(), attrs));
                break;
                
            case XmlNodeType.EndElement :
                ElemTuple t = elemsStack.Pop();
                int ei = context.AddElement(new ElementStruct(this, t.V1, t.V2.ToArray(), t.V3));
                if (elemsStack.Count > 0)
                    elemsStack.Peek().V2.Add(ei);
                break;
        }
}

ПК>int i;
ПК>tie(i, ignore) = t;
ПК>

using Nemerle.IO;

def t : double * string = (1.0, "aaa");

print("$t\n");

>> i = t.get<0>();        // ok
>>

ПК>i = get<0>( t );
ПК>

t[0]

[Nemerle.MacroUsage (Nemerle.MacroPhase.WithTypedMembers,
                                         Nemerle.MacroTargets.Class,
                                         Inherited = false, AllowMultiple = false)]
macro TupleToString (t : TypeBuilder)
{
    def flds = t.GetFields (BindingFlags.Public %| BindingFlags.NonPublic %|          
                                                    BindingFlags.Instance %| BindingFlags.DeclaredOnly);
    def appends = List.RevMap (flds, fun (x : IField)
        { 
            <[ ignore (str.Append ($(x.Name : usesite).ToString ())); ]>
        });
    def body_seq = List.FoldLeft (List.Tail (appends), List.Head (appends) ::
                                     [<[ ignore (str.Append (")")); str.ToString () ]>], fun (x, acc)
        {
            x :: <[ ignore (str.Append (", ")) ]> :: acc
        });
        
    def body_seq = <[ def str = System.Text.StringBuilder ("(") ]> :: body_seq;

    t.Define (<[ decl:
        public override ToString () : string { ..$body_seq }
    ]>);
}

>> (1, "ss")
>>

Within the same program, two anonymous object initializers that specify a sequence of properties of the same names and types in the same order will produce instances of the same anonymous type.

K>// tie(...) { return Tie<>(...); } где Tie - хелпер-класс распаковки кортежей

Tuples
def t = (1, "one");: a tuple is a set of values which no name to recognise them
def fst = t[0];: use 0-based index to get the items

// Добавляем в начала списока параметров парамер содержащий строку формата.
// сам список параметров при этом разворачиваем, так как формировался он в обратном порядке.
def args = <[ $(Helper.GenerateId() : string) ]> :: args.Reverse();

...

// Формируем выражение форматированного вывода и возвращаем его как результат работы макроса.
// Этот код заместит вызов макроса. Консрукция ( .. $args) сформирует кортэж с параметрами.
// В Nemerle кортежи и списки параметров функций равнозначны. Так что можно считать, что 
// сформирован список парамтеров!
<[ Localiser._instace.Format( .. $args) ]>

ПК>auto tuple1 = make_tuple(1, "text", 1.2);
ПК>call(&F, tuple1);
ПК>

std::string & first()
  {
    static std::string s;
    return s;
  }

std::string global;
std::string & second()
  {
    return global;
  }

VD>Нда, вести родство с языками программирования... это жуе... уууу...

S>> б) Тем что он compile-time

VD>А... А у "их" значичь другой?

Может тогда расскажешь чем он лучше KeyValuePair<K, V>?

S>> в) тем что Владу он не понравился ( Влад грил, что он использовал Tuple )

ПК>>int i;
ПК>>tie(i, ignore) = t;
ПК>>

def (i : int, _) = t;

// Tie function templates -------------------------------------------------
template<class T1>
inline tuple<T1&> tie(T1& t1) {
  return tuple<T1&> (t1);
}

template<class T1, class T2>
inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
  return tuple<T1&, T2&> (t1, t2);
}

template<class T1, class T2, class T3>
inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
  return tuple<T1&, T2&, T3&> (t1, t2, t3);
}
...

using Nemerle.Compiler;
using Nemerle.Macros;

macro TupleTypeToString(tuple, verbose : bool = false)
{
    def getTupleArgs(tupleExpr)
    {
        match (tupleExpr.Type.Fix())
        {
            | MType.Tuple (args) => args
            | _ => Message.FatalError($"expected expression of tuple type, got $(tupleExpr.Type)")
        }
    }
    
    def tupleArgs = getTupleArgs(ImplicitCTX().TypeExpr(tuple));
    def sb = System.Text.StringBuilder("(");
    foreach(argType in tupleArgs)
        sb.Append(argType.Fix().ToString()).Append(" ");
    sb.Append(")");
    when (verbose)
        System.Console.WriteLine(sb);
    <[ $(sb.ToString() : string) ]>
}

using System;

def make_tuple[A,B](a : A, b : B) : A * B
{
    (a, b)
}

def x = make_tuple(1, "abc");
def y = (1, 2, 3, 4, 5, 6, 7, 8, 9);
def z = (System.Text.StringBuilder(), 2.0, 'a');
def xyz = (x, y, z);

def xTypeStr = TupleTypeToString(x);
def yTypeStr = TupleTypeToString(y);
def zTypeStr = TupleTypeToString(z);
_ = TupleTypeToString(xyz, true);

Console.WriteLine(xTypeStr);
Console.WriteLine(yTypeStr);
Console.WriteLine(zTypeStr);

((int * string) (int * int * int * int * int * int * int * int * int) (System.Text.StringBuilder * System.Double * char) )

// code skipped ...
      string text1 = "(int string )";
      string text2 = "(int int int int int int int int int )";
      string text3 = "(System.Text.StringBuilder System.Double char )";
      Console.WriteLine(text1);
      Console.WriteLine(text2);
      Console.WriteLine(text3);

using Nemerle.Compiler;

macro DumpTuple(tuple, action)
{
    def getTupleArgs(tupleExpr)
    {
        match (tupleExpr.Type.Fix())
        {
            | MType.Tuple(args) => args
            | _ => Message.FatalError($"expected expression of tuple type, got $(tupleExpr.Type)")
        }
    }
    
    def tupleArgs = getTupleArgs(Nemerle.Macros.ImplicitCTX().TypeExpr(tuple));
    mutable (i, code) = (0, []);
    for(;i < tupleArgs.Length; i++)
        code = <[ $action($tuple[$(i : int)]) ]> :: code;
    <[ { .. $(code.Reverse()) }]>
}

using System.Console;

module Test
{
    public Print(n : int) : void
    {
        WriteLine("int: {0}", n);
    }
    public Print(str : string) : void
    {
        WriteLine("string: \"{0}\"", str);
    }
    public Print(str : System.Text.StringBuilder) : void
    {
        WriteLine("StringBuilder: \"{0}\"", str);
    }
    public Print(n : double) : void
    {
        WriteLine("double: {0}", n);
    }
    public Print(n : char) : void
    {
        WriteLine("char: '{0}'", n);
    }
    public Print[A,B](obj : A * B) : void
    {
        WriteLine("tuple2[{0},{1}]: {2}", typeof(A), typeof(B), obj);
    }
    public Print[A,B,C](obj : A * B * C) : void
    {
        WriteLine("tuple3[{0},{1},{2}]: {3}", typeof(A), typeof(B), typeof(C), obj);
    }
    public Print(obj : object) : void
    {
        WriteLine("uknown object: {0}", obj);
    }
}

def make_tuple[A,B](a : A, b : B) : A * B
{
    (a, b)
}

def x = make_tuple(1, "abc");
def y = (1, 2, 3, 4, 5, 6, 7, 8, 9);
def z = (System.Text.StringBuilder(), 2.0, 'a');
def xyz = (x, y, z);

DumpTuple(x, Test.Print);
DumpTuple(y, Test.Print);
DumpTuple(z, Test.Print);
DumpTuple(xyz, Test.Print);

int: 1
string: "abc"
int: 1
int: 2
int: 3
int: 4
int: 5
int: 6
int: 7
int: 8
int: 9
StringBuilder: ""
double: 2
char: 'a'
tuple2[System.Int32,System.String]: (1, abc)
uknown object: (1, 2, 3, 4, 5, 6, 7, 8, 9)
tuple3[System.Text.StringBuilder,System.Double,System.Char]: (, 2, a)

Может тогда расскажешь чем он лучше KeyValuePair<K, V>?

S>>ЗЫ Я на Вашей стороне — пользоваться Туплами одинаково неудобно и на С№ и на С++. Просто на Шареп пишут менее терпимые и более разнеженные, а С++ серам, суровым парням, лишних пару байт набить на клавиатуре, либо распознгать и интерпретировать при промотре исходникоф — не в западло

VD>Понимаш ли в чем дело? Разница между нашими подходами в том, что ты думашь сколько ты набьешь кода, а я о том насколько понятным будет мой код. Только и всего.

S>

def divmod (x, y) {
  def div = x / y;
  def mod = x % y;
  (div, mod)
}
 
match (divmod (142, 13)) {
  | (d, m) =>
    System.Console.WriteLine ($ "div=$d, mod=$m");
}
 
// Output: div=10, mod=12

def (d, m) = divmod (142, 13);

System.Console.WriteLine ($ "div=$d, mod=$m");