ПК>>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)