Proposal: User definable type constraints on polymorphic parameters

[tgschultz]

As shown in #1268 (and to an extent #130), several users have requested some form of comptime interfaces/contracts/concepts/typeclasses/insert-terminology-here. While the current status-quo, duck typing, is sufficient to provide the desired functionality, it does not offer many clues as to what the parametric function is looking for, and errors thrown for performing an illegal operation on the passed-in type can occur in the middle of large function bodies, obscuring that source of the problem (the function was passed an inappropriate type).

I propose a change to the var keyword allowing it to take a parameter of type fn(type)bool. At comptime, when a new type is passed in the parametric parameter, the compiler will evaluate the function against the type of the passed parameter and, if the result is false, throw an appropriate compile error identifying the constraint function, the passed parameter type, and the call site of the parametric procedure.

std.meta.trait, recently merged in #1662, provides several simple introspection functions that could be used in this way:

const trait = std.meta.trait;

pub fn reverseInPlace(list: var<isIndexable>) void {
    ...
}

pub fn createWorld(allocator: var<hasFn("alloc")>) []Things {
    ...
}

const isVector = multiTrait(
    TraitList.{
        hasField("x"),
        hasField("y"),
        hasField("z"),
    }
);

pub fn dot(a: var<isVector>, b: @typeOf(a)) @typeOf(a) {
    ...
}

But since the constraint functions are completely user-definable, they can be arbitrarily complex.

pub fn isChildOf(comptime P: type) trait.TraitFn {
    return struct.{
        pub fn trait(comptime T: type) bool {
            switch(@typeId(T)) {
                builtin.TypeId.Pointer => {
                    const info = @typeInfo(T).Pointer;
                    switch(info.Size) {
                        builtin.TypeInfo.Pointer.Size.One => {
                            if(@typeId(info.child) == builtin.TypeId.Array) return meta.Child(info.child) == T;
                            return info.child == T;
                        },
                        else => return info.child == T,
                    }
                },
                builtin.TypeId.Array,
                builtin.TypeId.Optional,
                builtin.TypeId.Promise => return meta.Child(P) == T,
                else => return false,
            }
        }
    }.trait;
}

pub fn indexOf(list: var<isIndexable>, item: var<isChildOf(@typeOf(list))>) !usize {
    ...
}

See this gist for an overly complex example.

[williamcol3]

I'm a much bigger fan of this form of constraint checking compared to any other option I've seen (e.g. an interface definition). It is a much more general solution that avoids locally maximizing.

[Hejsil]

We can take this to the extreme if we want. We really don't need var with a system like this in place. We can define, that a parameter is Keyword_comptime? <Identifier>: <Expr>, where <Expr> is any expression that evaluates into something of type type or fn(type)bool.

With this, we can define var like this if we want to:

fn isAny(comptime T: type) bool {
    return true;
}

fn generic(any: isAny) @typeOf(any) {
    return any;
}

I don't think we lose much readability. type variables should be TitleCase and functions should be snakeCase according to the style guide, so it should be clear that isAny is not a type based on the name alone.

It's always good to remove features when possible, and with a system like this, var is no longer needed.

[Hejsil]

And another thing that would be nice, is if functions without a body was allowed to be declared. This would allow us to have an abstraction like this:

const isSomething = interface(struct {
    x: u8,
    y: u8,

    pub fn add(@This(), @This()) @This();
});

Currently, this is not possible:

pub fn a() void; // test.zig:1:5: error: non-extern function has no body

test "" {
    @compileLog(@typeOf(a)); // test.zig:4:25: error: use of undeclared identifier 'a'
}

I really think the error error: non-extern function has no body should happen when a leaves comptime and goes into runtime (aka, trying to call a or storing it in a variable).

[Rocknest]

@Hejsil i do like explicitness of var.

..and for example if i would like to use var just like now then i would probably need to declare something like this fn func(any: std.meta.any) @typeOf(any) or create the function instead of importing.

Just want to share my idea of what zig interfaces could look like. Note the angle brackets to distinguish interface implementations from normal types:

// wrap "iface" keyword in compiletime function to get generics
fn createIEventListener(comptime message: type){
	return iface{
		fire : fn(@This(),message) void,
	}
}

// defining the interface identifier
const IEventListenerMessageU8 = createIEventListener(u8);
const IEventListenerMessageMouseEvent = createIEventListener(MouseEvent);

const MyListenerU8 = struct{
	comptime{
			// tell compiler that instances of this struct shall comply to the given interface
		assertImplements(IEventListenerMessageU8,This());
	}
	fn fire(msg : u8) void{
		switch(msg){ ....
		}
	}
}

// (an artificial) example of making a parameter taking interface implementations
fn fireIfGameOver(gamestate: *GameState, listener : <IEventListenerMessageU8>){
	if(...) listener.fire(5)
}

// passing implementations into a function taking an interface:
// -> compile error if the passed type was determined to not implement the interface properly.
fn main(){
	...
	const listener = MyListenerU8.init();
	while(gamestate.running()){
		fireIfGameOver(gamestate,listener);
	}
}

Another example here: https://gist.github.com/user00e00/85f106624557b718673d51a8458dbab8