function f(a : number) : number {..}
function g() : number {..}
function h(c : number, d : number) {..}

var x = f();
f(g()); // OK
f(x); // OK
h(f(), g()); // OK

function f(a : void) {..}
function g(b : void) {..}
function h(c : void, d : void) {..}

var x = f();
f(g()); // OK ?
f(x); // OK ?
h(f(), g()); // OK ?

def u():Unit = {}  
def i():Int = 1         

val t = if(...) f() else i()

t match{
  case _:Unit => println("Unit")
  case i:Int => println(i)}

_NN>А с void ?

_NN>function f(a : void) {..}
_NN>function g(b : void) {..}
_NN>function h(c : void, d : void) {..}

_NN>var x = f();
_NN>f(g()); // OK ?
_NN>f(x); // OK ?
_NN>h(f(), g()); // OK ?
_NN>

> let f () = ()
> :t f
f :: () -> ()
> let h () () = 42
> :t h
h :: Num a => () -> () -> a
> let x = f ()
> f x
()
> h (f ()) (f ())
42

function foo(int x, int y, int z){}
foo(1,,3);

foo(1,"hello",3);

_NN>Боюсь люди получат тут разрыв шаблона если будет два пустых значения

function foo() : int, float {return 10, 3.14;}
x,y = foo();

function bar(char c, int x, float f, string s) {}
bar('q',foo(),"hello");

bar(v(), 'q', v(), v(), 100, 1.23, v(), "hello", v(), v());

function v() {}
function foo() {}
function bar(int) {}

foo();    // OK
foo(v()); // OK?

bar(100); // OK
bar(100, v(), v(), v()); // OK???

_>Пока не рассматриваем случай Nullable<void>/void? который уже bool получается, и при этом попадает под требование работы с void как с обычными типами

_>var hashSet = new Dictionary<int, void>(); эта коллекция превращается в Set. При этом метод hashSet.Add(key : TKey, value : TValue), внезапно начинает компилироваться с одним аргументом hashSet.Add(5), так как void в недостающие места компилятор и сам подсунуть может. Красота

void F() {}

F(); // OK
F( () ); // OK
F( () , () );// OK

void G() {}
F( G(), G(), G() );

_NN>>Боюсь люди получат тут разрыв шаблона если будет два пустых значения

NC>Есть еще http://en.wikipedia.org/wiki/Bottom_type

bar(v(), 'q', v(), v(), 100, 1.23, v(), "hello", v(), v());

F(a : int) : void {}
G() : void {}

F({ Do1(); Do2(); 1 }); // <--> Do1(); Do2(); F(1);
G({ Do1(); Do2(); () }); // <--> Do1(); Do2(); F();

function foo(void, int, void);

foo(v(), 100, v());

function foo(void, int, void);

foo(v(), 100, v());

#include <iostream>
using namespace std;

void g() {cout<<"g";}
void f(int) {cout<<"f";}

int main()
{
    f( (g(), 1) );

    return 0;
}

gf

_NN>#include <iostream>
_NN>using namespace std;

_NN>void g() {cout<<"g";}
_NN>void f(int) {cout<<"f";}

_NN>int main()
_NN>{
_NN>    f( (g(), 1) );

_NN>    return 0;
_NN>}
_NN>

_NN>gf
_NN>

f( g(), 1 );
f( g(), g(), 1, g(), g() );
// и т.д.

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);

3.2.4 The Void Type
The Void type, referenced by the void keyword, represents the absence of a value and is used as the return type of functions with no return value.
The only possible values for the Void type are null and undefined. The Void type is a subtype of the Any type and a supertype of the Null and Undefined types, but otherwise Void is unrelated to all other types.

NOTE: We might consider disallowing declaring variables of type Void as they serve no useful purpose. However, because Void is permitted as a type argument to a generic type or function it is not feasible to disallow Void properties or parameters.

interface A<T> {
 f(x:number,a: T);
}

<A<void>>(null).f(1); // <> это приведение типа, т.е. в стиле C: ((A<void>)(null)).f(1)

var a = <A<void>>(null);
a.f(1);

interface A<T> {
 f(x:number,a: T);
}

class B implements A<void> {
 f(x:number) {}
}

interface A<T> {
 f(x:number,a: T);
}

class B implements A<void> {
 f(x:number, a:void) {}
}


new B().f(1); // Error
// Надо так
// new B().f(1, undefined);

_NN>var a = <A<void>>(null);
_NN>a.f(1);
_NN>

<A<void>>(null).f(1) == (<A<void>>)((null).f(1))

(<A<void>>(null)).f(1)

The void type, in several programming languages derived from C and Algol68, is the type for the result of a function that returns normally, but does not provide a result value to its caller.