D - Aliases

Alias, as the name refers provides an alternate name for existing names. The syntax for alias is shown below.

alias new_name = existing_name;

The following is the older syntax, just in case you refer some older format examples. Its is strongly discouraged the use of this.

alias existing_name new_name;

There is also another syntax that is used with expression and it is given below in which we can directly use the alias name instead of the expression.

alias expression alias_name ;

As you may know, a typedef adds the ability to create new types. Alias can do the work of a typedef and even more. A simple example for using alias is shown below that uses the std.conv header which provides the type conversion ability.

import std.stdio;
import std.conv:to;

alias  to!(string) toString;

void main()
{
   int a = 10;

   string s = "Test"~toString(a);
   writeln(s);
}

When the above code is compiled and executed, it produces result something as follows:

Test10

In the above example instead of using to!string(a), we have assigned it to alias name toString making it more convenient and simpler to understand for us.

Alias for a Tuple

Let us a look at another example where we can set alias name for a Tuple.

import std.stdio;
import std.typetuple;

alias TypeTuple!(int, long) TL;

void method1(TL tl)
{
   writeln(tl[0],"\t", tl[1] );
}

void main()
{
   method1(5, 6L);   
}

When the above code is compiled and executed, it produces result something as follows:

5 6

In the above example, the type tuple is assigned to the alias variable and it simplifies the method definition and access of variables. This kind of access is even more useful when we try to reuse such type tuples.

Alias for data types

Many times, we may define common data types that needs to be used across the application. When multiple programmers code an application, it can be cases where one person uses int, another double and so on. To avoid such conflicts, we often use types for data types. A simple example is shown below.

import std.stdio;

alias int myAppNumber;
alias string myAppString;

void main()
{
   myAppNumber i = 10;
   myAppString s = "TestString";
  
   writeln(i,s);  
}

When the above code is compiled and executed, it produces result something as follows:

10TestString

Alias for class variables

In case you are new to the concept of classes and inheritance, have a look at the tutorial on classes and inheritance before starting with this section. There is often a requirement where we need to access the member variables of the superclass in the subclass, this can made possible with alias, possibly under a different name. A simple example is shown below.

import std.stdio;

class Shape
{
   int area;
}

class Square : Shape
{
   string name() const @property
   {
      return "Square";
   }
    
   alias Shape.area squareArea;
}


void main()
{
   auto square = new Square;

   square.squareArea = 42;

   writeln(square.name);
   writeln(square.squareArea);
}

When the above code is compiled and executed, it produces result something as follows:

10TestString

alias this

alias this provides the capability of automatic type conversions of user-defined types. The syntax is shown below where the keywords alias and this are written on either sides of the member variable or member function.

alias member_variable_or_member_function this;

An example is shown below to show the power of alias this.

import std.stdio;

struct Rectangle
{
   long length;
   long breadth;

   double value() const @property
   {
      return cast(double) length * breadth;
   }

   alias value this;
}

double volume(double rectangle, double height)
{
   return  rectangle * height;
}

void main()
{
   auto rectangle = Rectangle(2, 3);

   writeln(volume(rectangle, 5));
}

In the above example, you can see that the struct rectangle is converted to double value with the help of alias this method. hen this code is compiled and executed, it produces result something as follows:

30