/*in parameters*/(string param1, int param2) FuncName /*out parameters*/(string ret1, int ret2)
{
}

/*in parameters*/(string param1) FuncName /*out parameters*/(int ret2)
{
}

(string ret1, int ret2) FuncName(string param1, int param2)
{
}

(string ret1) FuncName(int param2)
{
}

string FuncName(string param1, inout int param2)
{
}

string FuncName(string param1, out int param2)
{
}

def (var1, var2, var3) = f();

def x = f();
... = x.var1 + x.var2;
... x.var3

VD>(string ret1, int ret2) FuncName(string param1, int param2)
VD>{
VD>}

VD>(string ret1) FuncName(int param2)
VD>{
VD>}
VD>

{string ret1, int ret2} FuncName(string param1, int param2)
{
}

{ r1, r2 } = Func(p1, p2);

{ string ret1, int ret2 } FuncName(string param1, { string p1, int p2 })

var x = Foo(); // возвращает анонимный тип с сигнатурой, вынесенной в сигнатуру метода Foo()
Console.WriteLine(x.a);

{ a1, b1 } = Foo();
Console.WriteLine(a1);

("aaa", 12)

f("aaa", 12)

void f(int x, List<int * string> xs)

void f(int x, List<int x, string name> xs)

S>{ r1, r2 } = Func(p1, p2);
S>

S>{ string ret1, int ret2 } FuncName(string param1, { string p1, int p2 })
S>

data (,) a b = (,) a b
data (,,) a b c = (,,) a b c
data (,,,) a b c d = (,,,) a b c d
data (,,,,) a b c d e = (,,,,) a b c d e
data (,,,,,) a b c d e f = (,,,,,) a b c d e f
data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g
data (,,,,,,,) a b c d e f g h = (,,,,,,,) a b c d e f g h
data (,,,,,,,,) a b c d e f g h i = (,,,,,,,,) a b c d e f g h i
data (,,,,,,,,,) a b c d e f g h i j = (,,,,,,,,,) a b c d e f g h i j

struct Tst
{
    int x;
    int y;
}

void tst(int x, int y)
{
}

void main()
{
    Tst t1;
    tst(t1.tupleof);
}

VD>def x = f();
VD>... = x.var1 + x.var2;
VD>... x.var3

(left, right) = getBranches(tree)
doSmthgWith(left, right)

branches = getBranches(tree)
doSmthgWith(branches.left, branches.right)

int a, b;
a = GetSomeInt();
GetSomeInt(out b); // в плюсах был бы соответственно &b

(int a, string b) = GetSomePair();

GetSomePair(out a, out b);

int a = GetSomeInt();
(int a) = GetSomeInt();

void Func(int &sum, int start, int end)
{
  for(int i=start; i<end; i++)
    sum*= i;
}

void Func(out int sum, int start, int end)
{
  sum=start; // тут опять тонкости definite assignment, связанные с out - компилятор не даёт программисту полагаться на начальное значение этого параметра
  for(int i=start; i<end; i++)
    sum*= i;
}

PD>А это уже просто специфика операции присваивания, которая прямого отношения к вызову функции не имеет . Вызов функции сам по себе, а дальше присваивание, а там правила совместимости типов

SomeIntFunc(i, &f)

void SomeIntFunc(int a, int &b)

class IPoint {
public :
    int x, y;
};

class FPoint {
public :
    float x, y;
    FPoint(IPoint& ip)
    {
        x = ip.x;
        y = ip.y;
    }
};
IPoint GetPoint()
{
    IPoint p;
    p.x = p.y = 0;
    return p;
}

void GetPointByRef(IPoint& ip)
{
    ip.x = ip.y = 0;
}


int _tmain(int argc, _TCHAR* argv[])
{
    FPoint fp = GetPoint();

    IPoint ip;
    GetPointByRef(ip);
    FPoint fp1 = ip;
}

double f = GetSomeInt(); // работает
(double f) = GetSomeInt(); // не работает 
// мы помним, что строчка выше - всего лишь извращённый плод моего сознания, алиас для 
GetSomeInt(&f); // не работает, потому что &double не приводится к &int

(int modulo, int reminder) = IntDivide(arg, divisor); 
// не работает, если arg и divisor - byte; 
// при очевидном определении IntDivide как 
template<classname T>
void IntDivide(T arg, T divisor, T &modulo, T &remainder)
// вместо этого мне нужно вручную выписывать нудные промежуточные присваивания
// хотя вот такой код будет работать безо всяких проблем:
int modulo = arg / divisor; // здесь сработает очевидное расширение байта до инта
int remainder = arg % divisor; // но делить придётся дважды, вместо быстрой операции, которая получает сразу оба числа.

S>int a, b;
S>a = GetSomeInt();
S>GetSomeInt(out b); // в плюсах был бы соответственно &b
S>

a, b : Integer;
a = GetSomeInt();
GetSomeInt(b);

def x = ("aaa", 12);
f(x)

FPoint fp = GetPoint();

IPoint ip;
GetPointByRef(ip);
FPoint fp1 = ip;

FPoint fp1;
GetFPointByRef(fp1);

PD>>Бесплатный сыр бывает только в мышеловках

S>(int modulo, int reminder) = IntDivide(arg, divisor); 
S>// не работает, если arg и divisor - byte; 
S>// при очевидном определении IntDivide как 
S>template<classname T>
S>void IntDivide(T arg, T divisor, T &modulo, T &remainder)
S>// вместо этого мне нужно вручную выписывать нудные промежуточные присваивания
S>// хотя вот такой код будет работать безо всяких проблем:
S>int modulo = arg / divisor; // здесь сработает очевидное расширение байта до инта
S>int remainder = arg % divisor; // но делить придётся дважды, вместо быстрой операции, которая получает сразу оба числа.
S>

//...

template<class T>
tuple<T, T> f(T a, T b) //...

void g()
{
  typedef char byte;

  byte a = 17, b = 7;
  int i1, i2;
  double d1;
    
  tie(i1, i2) = f(a, b); // <byte, byte> -> <int, int>
  tie(i1, d1) = f(a, b); 
    
  tuple<float, float> t1 = f(a, b);   // <byte, byte> -> <float, float>
  tuple<int, float>   t2 = f(i1, i2);
}

double d = GetSomeFloat();

double x = GetSomeFloat()

(double x, double y) = GetFloatPoint()

IPoint ip;
GetPointByRef(ip);
FPoint fp1 = ip;

FPoint fp = GetPoint();

class Tuple2<A,B>
class Tuple3<A,B,C>
...

(int x, int y : x < y) F();

void Container::Remove(Key k : !this.Empty && this.Exists(k))

void Container::Remove(Container this_ : !this_.Empty, Key k : this_.Exists(k))

(this.Empty) Container::Container();

Container c;
c.Remove(key);

Container c; 
// в этой точке - c:{ this.Empty == true }

c.Remove // в этой произойдет обнаружение несоответствия ранее вычисленному значению

void f(int arg1, int arg2 = x, int arg3 = y);

// Отсутствующие значения принимают значения по умолчанию
f(arg1 = a, arg3 = b);

// Возвращает длину чего-то + что-то 
(int length, X x) f();

// В месте вызова эта длина используется как индекс 
(index, x) r = f();

var reverseList = sourceList.Reverse();

public static L Reverse<L, T>(this L source)
  where L: IEnumerable<T>
(
    T[] temp = source.ToArray();
    Array.Reverse(temp); 
    if (typeof(L).IsAssignableFrom(temp.GetType)
        return (L) temp;
    else
        return (L)Activator.CreateInstance(typeof(L), temp); 
)

var i = SomeFunc(a, b);
GlobalSettings.Instance.Property = SomeOtherFunc(a, b);

(var i, GlobalSettings.Instance.Property) = CombinedFunc(a, b);

(int x, int y : x < y) F();

int x : x >= 10 F();

ЮЖ>void Container::Remove(Key k : !this.Empty && this.Exists(k))
ЮЖ>

ЮЖ>void Container::Remove(Container this_ : !this_.Empty, Key k : this_.Exists(k))
ЮЖ>

public void Test(Dictionary<string, int> data)
{
  data["test"] = GetExternalInt(); // тип data неявно сменился
  
  int a = data["test"]; // компилятор пропускает, потому что там точно лежит int
  
  int b = data["fail"]; // компилятор ругается, потому что нет гарантии наличия ключа
  
  int? c = data["fail"]; // компилятор спокоен, потому что мы явно предусмотрели отсутствие ключа

  int d = 0;  
  if (data.Exists("fail")) // тип data неявно сменился 
    int d = data["fail"]; // компилятор спокоен, потому что в этой ветке есть гарантия наличия ключа
}