Implement issue# 16744: TypeOf template helper.

[jmdavis]

typeof cannot be used directly with templates such as staticMap, because
we don't have the template equivalent of lambda functions. TypeOf is
therefore a template wrapper around typeof so that it can be used in
contexts that require a template.

[PetarKirov]

How about:

/++
    Returns:
        The type of the expression `exp` or `T`
        if the argument is already a type.

    Useful when combined with higher-order templates
    such as $(REF, staticMap, std, meta).
 +/
alias TypeOf(alias exp) = typeof(exp);

/// ditto
alias TypeOf(T) = T;

unittest
{
    import std.meta : AliasSeq, staticMap;

    static assert(is(TypeOf!1 == int));
    static assert(is(TypeOf!"hello" == string));
    static assert(is(TypeOf!(17 + 42) == int));

    int[] arr;
    static assert(is(TypeOf!arr == int[]));

    static assert(is(staticMap!(TypeOf, 1, true, "hello") ==
        AliasSeq!(int, bool, string)));

    struct S {}
    static assert(is(staticMap!(TypeOf, 1, true, int, bool, short, S.init, S) ==
        AliasSeq!(int, bool, int, bool, short, S, S)));
}

In other words:

• Short templated alias and enum declarations don't need the full template syntax
• Add identity template overload so you can get the types of a heterogeneous alias sequences, that include types in addition to expressions

[jmdavis]

It doesn't return anything, so having a "returns" section just seems wrong to me. The docs what it does, and the examples show it.

I could reduce it to the one-liner, and if folks want me to, that's fine, but I don't see much benefit. It works either way.

Regardless, I completely disagree with having it work with stuff that typeof doesn't work with. The whole point was to turn typeof into a template. And in general, mixing types and expressions in the same AliasSeq is a bad idea except when you're using it to as a template argument list, in which case, you wouldn't be doing stuff like staticMap on it, and something like TypeOf would not be appropriate.

[PetarKirov]

It doesn't return anything, so having a "returns" section just seems wrong to me. The docs what it does, and the examples show it.

I don't have a strong opinion about this, though the templates in std.meta are often called meta-functions and naturally each function returns something. E.g. type functions (like std.traits.Unqual) accept types and return types. Similarly, templateNot is meta-function that takes a template and returns a template. Yes, that's accomplished through an alias declaration, but that's just a syntax detail. I think the function metaphor makes the most sense from the users' point of view.

I could reduce it to the one-liner, and if folks want me to, that's fine, but I don't see much benefit. It works either way.

In general, I believe that code should pay for itself. I.e. there shouldn't be any unnecessary code. Shorter code is most often easier to read and understand.

Regardless, I completely disagree with having it work with stuff that typeof doesn't work with. The whole point was to turn typeof into a template. And in general, mixing types and expressions in the same AliasSeq is a bad idea except when you're using it to as a template argument list, in which case, you wouldn't be doing stuff like staticMap on it, and something like TypeOf would not be appropriate.

I disagree. A generic library should not impose arbitrary restrictions on its users. This is like saying that Alias should support not support types, except for built-in ones, because you can already alias them without the need for Alias. It may not sound immediately useful, but comes up in generic code often enough, that I think it would be useful. Consider for example:

static assert(SizeOf!(3 + 4) == 4);
static assert(SizeOf!int == 4);
static assert(SizeOf!"asd" == 2 * size_t.sizeof);
static assert(SizeOf!'c' == 1);

template SizeOf(T...)
    if (T.length == 1)
{
    enum SizeOf = TypeOf!(T[0]).sizeof;
}

Why would the writer of SizeOf need to special case types from expressions? This is a problem that is better fixed in one place, rather than duplicating boilerplate everywhere.

[jmdavis]

I disagree. A generic library should not impose arbitrary restrictions on its users.

There is nothing arbitrary about the restriction. typeof gives you the type of its argument. TypeOf does the same. It makes no sense to get the type of a type.

[MetaLang]

I agree that we should not change how typeof works, as that would likely be a huge breaking change. The best we can do is add a helper template like this.

Ping @andralex so we can finally get this merged.

Also @jmdavis please rebase.

[MetaLang]

Please change to Typeof so it matches the built-in operator.

[jmdavis]

That wouldn't match the naming conventions or how other templates in std.traits are named.

[MetaLang]

This is better implemented as @ZombineDev described.

[jmdavis]

Have TypeOf work on types even though typeof doesn't work on types? As I said, I don't think that it makes any sense to get the type of a type, and I'm not going to make that change.

[MetaLang]

Plenty of other templates in this module use the word "returns", so please add a Returns: section here, as well as Params:. See https://github.com/jmdavis/phobos/blob/95112dc7cabe31ab3b63679d0c8a283d6dfef496/std/traits.d#L2034 for an example.

[MetaLang]

Please add a unit test or two for types as well.

[andralex]

How often do we need staticMap with typeof in the standard library? The savings should be considerable; otherwise we can just leave the one-liner as an example.

[jmdavis]

How often do we need staticMap with typeof in the standard library? The savings should be considerable; otherwise we can just leave the one-liner as an example.

I don't follow. Do you want the implementation changed in some way, or do you disagree with the fact that staticMap is used in an example? Being able to use this template with something like staticMap is pretty much the whole reason to create it. If you're not passing this template to another template like staticMap, then you'd just use typeof directly.

[andralex]

@jmdavis the simplest question is: since it's a trivial one-liner, why not just ask the user to do it if they have a need? We need to have a case for high frequency of use.

Also: copying typeof 100% seems a dubious goal. It's like doing our very best to not be creative. How about we do something better and more general that includes what typeof does, and also more wonderful things? I'm thinking e.g. TypesOf!(a, b, c) returns an AliasSeq consisting of the types of a, b, and c. If you only pass one expression, you get its type.

[PetarKirov]

Closing in favor of #5662