On Tuesday, 17 August 2021 at 20:29:51 UTC, james.p.leblanc wrote:

https://run.dlang.io/is/m5svQ2

The error was in line 8.
T (Teoh) forgot to take the first of S in is(T == S[0]). The error message improves after adding the ! in isAmong!(T, S[1..$]), which, surprisingly, is optional!

— Bastiaan.

On Tuesday, 17 August 2021 at 20:28:20 UTC, Alexandru Ermicioi wrote:

I've been happily trying to absorb all the helpful concepts posted.

A final related question in the quest for simplicity and robustness.

If I wanted to ensure that a function accepts only arguments of
byte, int, uint, long, etc. (i.e. integer-like types). Is the accepted
way to do this like so?:

auto foo( T : long )(T a, T b){ ... }

I really wish I could find a good explanation of the ":" (colon)
used in templates. I am sure one exists ...but haven't come upon
it just yet.

(I thought "isIntegral" in traits module would be helpful...but
I failed in my experiments.)

Thanks for patience with this question!

Best Regards,
James

On Wednesday, 18 August 2021 at 05:33:13 UTC, james.p.leblanc wrote:

I very much prefer the ususal constraint syntax

auto foo(T)(T a, T b) if(isIntegral!T) { ... }

On Wednesday, 18 August 2021 at 05:33:13 UTC, james.p.leblanc wrote:

A template specialization is basically a template overload.

For example:

void func(int a){
      writeln("argument is integer");
}

void func(long a){
      writeln("argument is long");
}

void main(){
     int a;
     long b;
     func(a);
     func(b);
}

The above does what you expect.

Now the template specialization way:

void funcTemplate(T:int)(T a){
     writeln("argument is int");
}

void funcTemplate(T : long)(T a){
     writeln("argument is long");
}

void main(){
     int c;
     long d;
     funcTemplate(c);
     funcTemplate(d);
}

The above will also do what you expect.

Template specialization is basically overloading for templates, nothing more.

Below is a complete working copy-paste example combining both:

import std;



void func(int a){
      writeln("argument is integer");
}

void func(long a){
      writeln("argument is long");
}



void funcTemplate(T:int)(T a){
     writeln("argument is int");
}

void funcTemplate(T : long)(T a){
     writeln("argument is long integer");
}

void main(){
     int a;
     long b;
     func(a);
     func(b);

     funcTemplate(a);
     funcTemplate(b);

}

On Wednesday, 18 August 2021 at 06:53:51 UTC, Tejas wrote:

 funcTemplate(a);
 funcTemplate(b);

Domninikus, Tejas, and All,

I see that I had been (stupidly) omitting the exclamation point
after "isIntegral" in my clumsy attempts to use the traits ...
thanks for your clear example helping me identify my error.

Also, thanks for mentioning the words "template specialization" , I did
not know what to call the use of ":" in templates.

Now, I have a search term I can use to learn more ...and find it is in Phillippe
Signaud's informative "D-templates-tutorial".

Thanks again,
James

PS Also, I am enjoying, a entertaining and educational tutorial that Phillippe
has linked in his tutorial. Other may learn from this as well:

http://www.semitwist.com/articles/EfficientAndFlexible/SinglePage/