I need to generate some meta info of my data types. I do it this [way](https://gist.github.com/drug007/b0a00dada6c6ecbf46b4f6988401d4e2):
```D
import std.range, std.format, std.stdio, std.traits;

struct NestedType
{
    string s;
    double d;
}

struct Node
{
    string value;
    int i;
    NestedType nt;
    // Node[] children; // It makes Node to be a recursive data types
}

template Meta(A)
{
    static if (isRandomAccessRange!A)
        alias Meta = RaRMeta!A;
    else static if (isSomeString!A || isIntegral!A || isFloatingPoint!A)
        alias Meta = ScalarMeta!A;
    else
        alias Meta = AggregateMeta!A;
}

struct RaRMeta(A)
{
    alias ElementType = typeof(A.init[0]);
    Meta!ElementType[] model;
}

struct ScalarMeta(A) {}

struct AggregateMeta(A)
{
    static foreach (member; __traits(allMembers, A))
        mixin("Meta!(typeof(A.%1$s)) %1$s;".format(member));
}

void main()
{
    auto meta = Meta!Node();

    assert(meta.value == ScalarMeta!string());
    assert(meta.i == ScalarMeta!int());
    assert(meta.nt == AggregateMeta!NestedType());

    assert(meta.nt.s == ScalarMeta!string());
    assert(meta.nt.d == ScalarMeta!double());
}
```
It works. But when I try to wrap around a recursive data type (uncomment `children` member of `Node` type) it fails because during instantiating of `Meta!Node` it needs complete `Meta!Node` type to process `children` member of `Node`.

How can I "break" this recursion or some other work around to fix it?

On Monday, 8 July 2024 at 08:56:51 UTC, drug007 wrote:
> I need to generate some meta info of my data types. I do it this [...]
> How can I "break" this recursion or some other work around to fix it?

Use `Node*[]` for the children type. That way the compiler knows the size of the (previously) problematic member. In other words, instead of the need to know `Node` size, the compiler will not look further, it's a pointer.

On 09.07.2024 06:54, Steven Schveighoffer wrote:
> On Monday, 8 July 2024 at 08:56:51 UTC, drug007 wrote:
>> How can I "break" this recursion or some other work around to fix it?
> 
> A few ideas:
> 
> 1. If it's immediately recursive (that is, contains a pointer to itself), just use the type itself somehow. You may not be able to do this with recursive templates.
> 2. If the data itself is static, and not actually containing different things, defer the construction of the Meta members until needed. In other words, make them structs with a member which accesses the meta when requested.
> 3. In a project I have which constructs a parallel type on existing types, I use `opDispatch` to defer instantiation of the members until later. This may or may not work for you depending on the use case (you can't introspect `opDispatch`).
> 
> -Steve

Decided to use untyped array (like void[]) and then a decorator to make it typed one. It seems to be working, testing in progress.