...a;
import b;

foo(something);
bar(something);

foo and bar take different types that both...

...do with nested enums:
```
struct Foo
{
    enum Bar { A, B, }

    void func () {
        assert(A == 0...

...i);
void bar(Animal a);

foo(Animal.Jaguar); // OK
foo(Jaguar); // Error
bar(Jaguar); // OK...

...int x) const inout {
		return x;
	}
	auto bar(int x) const {
		return x;
	}
	auto baz...

...conditional atributes:

void foo()@(Pure!true){   //expand to `pure`

}

void bar()@(Pure!false){   //expand to `()`

}

```

...explicit array literal, i.e.:

void main()
{
    bar([S.init, S.init]);
}

In that case...

...struct bar{
        int i;
}
struct foo{
        bar i; alias i this;
}
void foobar(bar[] yo...

...T){
        class bar{
    		T t;
        }
    }

void func(alias F : foo!T, T)(F.bar f...

...need to repeat foo!(int).bar :)
    {
    }

    int main()
    {
            foo!(int).bar fi;//brackets added, now...

...argument types !()(bar), candidates are:
temptest.d(10):        func(T)(foo!T.bar f)

I...