Вступление

Предыстория

/// Класс сообщения
/**
	@tparam TList Список формальных параметров, записанных в сообщении.
*/
template
<
	class Fun,
	class TList = Fun::inArgs
>
class Message : public AbstrMessage, public Functor < void, TList >
{
public:
	/// Стандартный конструктор для создания сообщения
	/**
		@param fun Функтор, обработчик сообщения. 
	*/
	Message( Fun fun ) :
		Functor< void, TList >(fun), iShift(sizeof(int32)), pFun(NULL)
		{
			pFun = reinterpret_cast<Fun*>(Functor< void, TList >::getFun());
		}

	~Message() { delete fun;}

	void translate(char* message);
	OutMessHandler::tempMem* form(int32 id);
	Fun* getFun() { return pFun; }

protected:
	/// Смещение в сообщении для чтения
	int iShift;
	Fun* pFun;

protected:

	#define arg(i) getVal<Parm##i>(ms, Type2Type<Parm##i>())

	/// Вызывается при обнаружении вызова этой команды
	/**
		Тут довольно сложная ситуация, есть структура с аргументами в виде строк и нужно вызвать
		нужный оператор функтора. Это достигается с помощью Int2Type, который играет здесь роль if'а.
	*/
	void translate( char* ms, Int2Type<0> argCount)
	{
		return (*this)();
	}

	/// Перегруженный аналог ConCommand::Translate( CON_COMMAND com, Int2Type<0> argCount) для 1 аргумента
	void translate( char* ms, Int2Type<1> argCount)
	{
		return (*this)( arg(1) );
	}
	/// Перегруженный аналог ConCommand::Translate( CON_COMMAND com, Int2Type<0> argCount) для 2 аргументов
	void translate( char* ms, Int2Type<2> argCount)
	{
		return (*this)( arg(1), arg(2));
	}
	/// Перегруженный аналог ConCommand::Translate( CON_COMMAND com, Int2Type<0> argCount) для 3 аргументов
	void translate( char* ms, Int2Type<3> argCount)
	{
		return (*this)( arg(1), arg(2), arg(3));
	}
	/// Перегруженный аналог ConCommand::Translate( CON_COMMAND com, Int2Type<0> argCount) для 4 аргументов
	void translate( char* ms, Int2Type<4> argCount)
	{
		return (*this)( arg(1), arg(2), arg(3), arg(4));
	}
	/// Перегруженный аналог ConCommand::Translate( CON_COMMAND com, Int2Type<0> argCount) для 5 аргументов
	void translate( char* ms, Int2Type<5> argCount)
	{
		return (*this)( arg(1), arg(2), arg(3), arg(4), arg(5));
	}
	//... and so on up to 20 arguments

	#undef arg

	/// Конвертация сырого сообщения в значение
	/**
		Берет строку и возвращает значение нужного типа.
		Поддерживаемые типы: POD типы, string.
		@note Нужны еще типы? Добавь в тело функции еще один else if.
		@attention Для неподдерживаемых типов не гарантируется стабильная работа программы =).
	*/
	template<typename T>
	T getVal( char* ms, Type2Type<T> t);

	/// Передача строки
	/**
		Строки передаются в C стиле с нулевым конечным символом.
	*/
	template< typename T >
	T getVal( char* ms, Type2Type<string> t);

};

Сильные стороны

Эффективность

Синтаксис

	string s = "some awesome string";
	...
	s = s[6..$];
	assert(s == "awesome string"); // Думаю ассерты знакомы многим, о поддержке обработки ошибок ниже

import std.stdio;
import std.algorithm;

void main() 
{
    foreach (line; stdin.byLine()) 
		foreach(word; splitter(line, " "))
		{
			writeln(word);
		}
}

	void someFunc(double a1, dobule a2)
	{
		// Типы выводятся на этапе компиляции
 		auto temp = new int[5];
		// здесь мы передаем лямбду некой функции, которая будет использовать ее позже
		sendAlgorithm(
			(double arg) // возвращаемые типы выводятся автоматически
			{
				// мы имеем доступ к переменным, где была создана лямбда
				writeln(a1,"+",a2,"?=",arg);
				return a1+a2 == arg;
			});
	}

Обработка ошибок

// Две абсолютно одинаковых функций с классической обработкой исключений и scope выражением:
void sendFile(Stream file)
{
	try
	{
		// Выдуманная функция, которая кидает исключение
		sendByBlocks(file);
	} catch(Exception e)
	{
		writeln("Передача файла не удалась!");
	} finally
	{
		// Вообще файл сам закроется, как только выйдет из зоны видимости, но это пример
		file.close();
	}
}

void sendFile(Stream file)
{
	scope(failure) // есть также success, который выполняется при отсутствии исключений
	{
		writeln("Передача файла не удалась!");
		file.close();
	}
	sendByBlocks(file);
}

unittest // В релизную версию тесты не попадают
{
	// Ассерты позволяют легко проверить работоспособность функции и вывести корретное сообщение об ошибке
	assert(myFunc() == expectedResult, "Тест моей функции провален!");
}

// В языке отсутствует множественное наследование классов, но можно наследовать много интерфейсов как в Java
interface SomeInterface
{
	double someFunc(double a1, double a2)
	in
	{
		// Проверяем входные данные
	}
	out(result)
	{
		// Проверяем выходные данные
	}
}

Обощенное программирование

	// Тип T передается во время компиляции
	// ref обозначет, что аргументы переданы по ссылке
	void swap(T)(ref T a1, ref T a2)
	{
		T temp = a1;
		a1 = a2;
		a2 = a1;
	}

	import std.traits;

	// Если guard выражение вернет false, то эта функция даже не рассматривается как кандидат для вызова
	string convert(T)(T arg) 
		if( isFloatingPoint!T )
	{
		//...
	}

	// Эта перегрузка будет вызвана только для класса myClass
	string convert(T)(T arg)
		if( is( T == myClass) )
	{
		//...
	}

// Эта функция может выполняться в compiletime
static string constructField(T)(string name)
{
	return T.stringof~" m"~name~";";
}

class MyClass
{
	// mixin внедряет строку как код на этапе компиляции
	// Результат: double mTime;
	// Знак "!" используется для указания compiletime аргументов
	mixin constructField!(double)("Time");
}

// В функцию можно передать сколько угодно интов, все они упакуются в аккуратный массив
int func1(int[] args...)
{
	int temp; // у каждого типа есть свойство init, которым инициализируется переменная
	foreach(arg; args)
		temp += arg;
	return temp;
}

// Это уже интереснее, в функцию можно передать сколько угодно различных аргументов различных типов
// все будет упаковано в специальный массив, такую нотацию использует writeln
int func2(T...)(T args...)
{
	foreach(i,arg; args)
	{
		// Типы аргументов тоже упакованы в массив
		writeln(i, " type: ", T[i].stringof, " ", arg);
	}
}

Многопоточность

Кроссплатформенность

version(Windows)
{
	...
}
version(linux)
{
	...
}
version(MacOS)
{
	...
}
// Меток версий ос просто уйма, можно посмотреть на офф. сайте
// также блоки версий можно использовать со своими константами для поддержки различных версий своего же софта

Недостатки