void v();
void foo();
foo(v(), v(), v())

NC>void v();
NC>void foo();
NC>foo(v(), v(), v())

void v();
void foo0(); void foo1(void); void fooT<T>(T);
foo0(v());    // запретить!
foo1(v());    // OK
foo1();       // OK
fooT(v());    // OK
fooT<void>(); // OK

fooT();       // запретить!

struct SVoid {};

n  = None # аналог void / unit
x  = 1
z  = 0

# кортежи
ns = ()
xs = (1,)
zs = (0,)
ys = (0,0) # сова? сова бьян!

print bool(n) # false - пустой тип
print bool(x) # true - ненулевое значение
print bool(z) # false - нулевое значение

print bool(ns) # false - пустой кортеж
print bool(xs) # true - непустой кортеж
print bool(zs) # true - непустой кортеж, хотя и из нулей

namespace std {
  struct unit_t
  {
    unit_t() {}
    template<class T> unit_t(T const&) {} // любой тип можно привести к void, а значит, и к unit
  };
  static unit_t const unit;
}

std::unit_t foo(std::unit_t x, std::unit_t y, std::unit_t z) { return std::unit; }
std::unit_t v() { return std::unit; }

int main()
{
  foo( v(), v(), (v(),v(),v()) ); // третий операнд использует оператор запятую
}

some foo(); // нуль-арная
some foo(void); // нуль-арная или, по-новому, унарная?

some foo(); // имея в виду some foo(void _ = void());

foo();
foo( void() );
foo( bar ); // приводя значение bar к void

Опять же, всякие ФВП приходится писать дважды — для функций, возвращающих значение, и для невозвращающих значение.

def f(a, b, c): print("a = {}, b = {}, c = {}".format(a, b, c))

x = (1,2,3)

f(*x)

a = 1, b = 2, c = 3

func foo() int { return 10;}
foo(); // теряем возвращаемое значение
_ = foo(); // так правильнее, но писать каждый раз лень!

func bar() int, float { return 10, 1.23; }
i, f = bar(); // ok
i = bar(); // ok, теряем второе значение
bar(); // ok, теряем все

// '@' - некоторая бинарная операция
x @ 1,2,3; // выполняется x @ 1, остальное выкидываем
x,y,z @ 1; // выполняется x @ 1, остальное выкидываем

_void_ = 1; // ok, ничего не происходит
x = _void_; // ok, ничего не происходит, значение x остается тем которое было до присваивания

 x = y * (z + _void_); // x = y*z

interface DictionaryOrSet<K, V> {
  add(key : K, value : V) : void;
}

class Dictionary<K,V> implements DictionaryOrSet<K,V> {
  add(key : K, value : V) : void { }
}

class Set<T> implements DictionaryOrSet<T,void> {
  add(value : T) : void { }
}

var d = new Dictionary<number, string>();
d.add(1, "A");

var s = new Set<number>();
s.add(1);