(In reply to Max Samukha from comment #0)
> mixin template Foo(A...) {
>     static if (A.length) {
>         void foo(A[0] a) {
>         }
> 
>         mixin Foo!(A[1..$]) F;
>         alias foo = F.foo;
>     }
> }
> 
> mixin Foo!(int, string, bool);
> 
> void main() {
> }
> 
> Error: alias test.Foo!(int, string, bool).Foo!(string, bool).Foo!bool.foo
> recursive alias declaration
> 
> 
> The mixin should produce properly nested overload sets of foo:
> 
> foo(int); foo(string); foo(bool);
> F.foo(string); F.foo(bool);
> F.F.foo(bool);

Hi, there is an error in your code, the correct way to write your template is:



mixin template Foo(A...)
{
    static if (A.length)
    {
        void foo(A[0] a) {}
        static if (A.length > 1) // here !!
        {
            mixin Foo!(A[1..$]) F;
            alias foo = F.foo;
        }
    }
}

mixin Foo!(int,string,bool);

void main() {}



otherwise the instanciation continues endlessly with an empty A.

(In reply to b2.temp from comment #1)

> 
> Hi, there is an error in your code, the correct way to write your template
> is:
> 
> 
> 
> mixin template Foo(A...)
> {
>     static if (A.length)
>     {
>         void foo(A[0] a) {}
>         static if (A.length > 1) // here !!
>         {
>             mixin Foo!(A[1..$]) F;
>             alias foo = F.foo;
>         }
>     }
> }
> 
> mixin Foo!(int,string,bool);
> 
> void main() {}
> 
> 
> 
> otherwise the instanciation continues endlessly with an empty A.

No. The base case is when A.length is zero. Remove the alias, and the example will compile.

Oops. You are right. In the original example, the wrong foo is aliased because the base case doesn't have one.