Proposal: Allow var to appear recursively in ParamDecl

[brodeuralexis]

Abstract

Allow var to appear inside generic arguments in the context of ParamDecl.

Problem

Considering the following generic:

fn Matrix(comptime N_: usize, comptime M_: usize, comptime T_: type) type {
    return struct {
        pub const N = N_;
        pub const M = M_;
        pub const T = T_;
        data: [N][M]T,
    };
}

When instantiating generics, an anonymous struct is created and cached for subsequent call to the generic with the same arguments.

While it is possible to get a type from a generic and some arguments (generic + arguments = type), it is not possible to get back the arguments from a generic and a concrete type (type - generic = arguments).

In order to have access the arguments of a generic, the values must be passed explicitly as other arguments to the function:

fn add(comptime N: usize, comptime M: usize, comptime T: type, matrix: Matrix(M, N, T), scalar: T) Matrix(N, M, T) 

Proposal

This proposal is to refine the use of anytype in the context of ParamDecl by allowing it to appear in arguments of generics like so:

fn add(matrix: Matrix(anytype, anytype, anytype), scalar: @typeOf(matrix).T) Matrix(@typeOf(matrix).N, @typeO(matrix).M, @typeOf(matrix).T)

Adding this feature to the language may also help prevent errors when using generic APIs like std.fmt, while being more helpful for language tools.

pub const Foo = struct {
    // ...

    pub fn format(value: Foo, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: std.io.Writer(anytype, anytype, anytype)) @typeOf(writer).Error!void  {
        // ...
    }
}

There is no need to add additional syntax or keywords to facilitate the extraction of the generic arguments' values, as simply exposing them as const values on the returned struct itself will allow one to get back the values with @typeOf(...).Arg.

Discussion

I believe this would required a change to the grammar to allow KEYWORD_anytype inside TypeExpr and do a validation pass on TypeExpr inside ParamDecl that are using KEYWORD_anytype.

If such a proposal is accepted, would it make sense to allow KEYWORD_anytype to also appear in all TypeExpr like variable declarations and return types, assuming that each anytype resolves to a single concrete sized type at compile time ?

// `anytype` resolves to f32.
var matrix: Matrix(3, 3, anytype) = Matrix(3, 3, f32).init();

pub fn MatrixBuilder(comptime N: usize, comptime M: usize) type {
    return struct {
        // `anytype` resolves to bool.
        pub fn ofBools() Matrix(N, M, anytype) {
            return Matrix(N, M, bool).init();
        } 
    };
}