## digitalmars.D.learn - Function template advice

Jordan Wilson <wilsonjord gmail.com> writes:
```I have a simple comparison function:

struct Foo {
string bar;
}

auto sameGroup(T,S) (T a, S b) {
static assert (is(T == string) || is(T == Foo));
static assert (is(S == string) || is(S == Foo));

string aStr;
string bStr;
static if (is(T == string)){
aStr = a;
} else {
aStr = a.bar;
}
static if (is(S == string)){
bStr = b;
} else {
bStr = b.bar;
}
return equal (aStr,bStr);
}

This works, but just wondered if there was an easier way?

Is there a way to do "static if" in shorthand, like:
auto aStr = (static if (is(T==string)) ? a : a.bar
```
Jan 18 2017
=?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
```On 01/18/2017 02:02 PM, Jordan Wilson wrote:
I have a simple comparison function:

struct Foo {
string bar;
}

auto sameGroup(T,S) (T a, S b) {
static assert (is(T == string) || is(T == Foo));
static assert (is(S == string) || is(S == Foo));

string aStr;
string bStr;
static if (is(T == string)){
aStr = a;
} else {
aStr = a.bar;
}
static if (is(S == string)){
bStr = b;
} else {
bStr = b.bar;
}
return equal (aStr,bStr);
}

This works, but just wondered if there was an easier way?

Is there a way to do "static if" in shorthand, like:
auto aStr = (static if (is(T==string)) ? a : a.bar

Yes, can be better with something similar to the following:

struct Foo {
string bar;
}

string value(U : Foo)(U u) {
return u.bar;
}

string value(U : string)(U u) {
return u;
}

auto sameGroup(T,S) (T a, S b) {
static assert (is(T == string) || is(T == Foo));
static assert (is(S == string) || is(S == Foo));

import std.algorithm;
return equal (value(a), value(b));
}

void main() {
assert(sameGroup("a", "b") == false);
assert(sameGroup("a", Foo("a")) == true);
assert(sameGroup(Foo("x"), "b") == false);
assert(sameGroup(Foo("z"), Foo("z")) == true);
}

Ali
```
Jan 18 2017
Jordan Wilson <wilsonjord gmail.com> writes:
```On Wednesday, 18 January 2017 at 22:39:02 UTC, Ali Ã‡ehreli wrote:
On 01/18/2017 02:02 PM, Jordan Wilson wrote:
[...]

Yes, can be better with something similar to the following:

struct Foo {
string bar;
}

string value(U : Foo)(U u) {
return u.bar;
}

string value(U : string)(U u) {
return u;
}

auto sameGroup(T,S) (T a, S b) {
static assert (is(T == string) || is(T == Foo));
static assert (is(S == string) || is(S == Foo));

import std.algorithm;
return equal (value(a), value(b));
}

void main() {
assert(sameGroup("a", "b") == false);
assert(sameGroup("a", Foo("a")) == true);
assert(sameGroup(Foo("x"), "b") == false);
assert(sameGroup(Foo("z"), Foo("z")) == true);
}

Ali

Nice, yes looks better thanks.
Jordan
```
Jan 18 2017