Type param Void

[andyli]

The following fails to be compiled, but I would expect one of the lines of ones or twos is valid.

class Test{
    static function main():Void {
        var voids:Array<Void> = [null, null, null];
        var ones = voids.map(function() return 1);  //Void -> Void should be (Void) -> Unknown<0>
        var twos = voids.map(function(v) return 2); //Arguments and variables of type Void are not allowed
    }
}

[ncannasse]

Array of Void does not make sense in the first place. Maybe we should actually forbid Void in type parameters unless @:generic ?

[Simn]

I think people like to use it for Signals or something.

[Simn]

But that's probably only Void -> Void or Something -> Void. I don't think using plain Void as a type parameter makes sense either.

[andyli]

As Simn mentioned, I was using it for Signals and promhx, to denote an event without any event data.
Some other time I use it with map as poor man's set:

var intset = new Map<Int, Void>();
intset.set(3, null);
trace(intset.exists(3)); //true

Anyway my use case is to have a type that accepts nothing but null. I could have used tink's Noise, but it sound strange to me to have more than one value to denote nothingness.

[Atry]

I think we should allow parameters of Null<Void>, for example:

class Nv
{
    static function main()
    {
        foo(null);
    }
    static function foo(nv:Null<Void>):Void
    {
    }
}

[Simn]

There's something about the Null<Void> idea that I like, but I'm not sure.

[Simn]

Another option would be to give some semantics to _ as a variable identifier and ignore the error in that case.

[Atry]

#3884

[Simn]

Something like this crashes the JVM generator with an EmptyStack exception:

interface I<T> {
	public function test():T;
}

class Main implements I<Void> {
	static function main() {}

	public function test() {}
}

I don't think such a thing should be allowed.

[kevinresol]

Please, forbid applying Void as type parameter.

[EliteMasterEric]

I would like to see some way to gracefully handle Void as a type parameter.

If I have a callback handler that takes T->Void, and I want to make a callback with no argument, I would set T to Void->Void, but that confuses the compiler because there's no argument that satisfies dispatch(value:T).

[kevinresol]

IMO, the Void -> Void notation is just an illusion that one can apply T = Void to T -> Void and make it () -> Void. I still vote for disallowing a plain Void being used as type param...