C++ to D

Wed Apr 1 06:59:09 PDT 2015

Hi,
Please help rewrite this code to D:

#include <iostream>

// Peano Arithmetic

struct zero;

template <typename T>
struct succ {
};

template <typename T>
struct increment {
	using result = succ<T>;
};

template <typename T>
struct decrement;

template <typename T>
struct decrement<succ<T>> {
	using result = T;
};

template <typename A, typename B>
struct addition;

template <typename A>
struct addition<A, zero> {
	using result = A;
};

template <typename A, typename T>
struct addition<A, succ<T>> {
	using result = typename addition<succ<A>, T>::result;
};

template <typename T>
struct to_int;

template <>
struct to_int<zero> {
	static constexpr auto result = 0;
};

template <typename T>
struct to_int<succ<T>> {
	static constexpr auto result = 1 + to_int<T>::result;
};

template <typename T>
using inc = typename increment<T>::result;

template <typename T>
using dec = typename decrement<T>::result;

template <typename A, typename B>
using add = typename addition<A, B>::result;

class nil;

template <typename T, typename Rest>
struct list {
	using head = T;
	using tail = Rest;
};

template <typename T>
struct length;

template <>
struct length<nil> {
	static constexpr auto result = 0;
};

template <typename Head, typename Tail>
struct length<list<Head, Tail>> { // pattern-matching
	static constexpr auto result = 1 + length<Tail>::result;
};

template <template <typename> class Func, class List>
struct map;

template <template <typename> class Func>
struct map<Func, nil> {
	using result = nil;
};

template <template <typename> class Func, class Head, class Tail>
struct map<Func, list<Head, Tail>> { // first-order function
	using result = list<Func<Head>, typename map<Func, 
Tail>::result>;
};

template <template <typename, typename> class Func, class Init, 
class List>
struct fold;

template <template <typename, typename> class Func, class Init>
struct fold<Func, Init, nil> {
	using result = Init;
};

template <template <typename, typename> class Func, class Init, 
class Head, class Tail>
struct fold<Func, Init, list<Head, Tail>> {
	using result = Func<Head, typename fold<Func, Init, 
Tail>::result>;
};

template <class List>
struct sum {
	using result = typename fold<add, zero, List>::result;
};

int main() {

	using one = inc<zero>;
	using two = inc<inc<zero>>;
	using four = inc<inc<inc<inc<zero>>>>;

	using two_plus_one = add<two, one>;
	std::cout << to_int<two_plus_one>::result << std::endl; // 
prints 3

	using l = list<one, list<two, list<four, nil>>>;
	std::cout << length<l>::result << std::endl; // prints 3

	using res = sum<map<inc, l>::result>::result;
	std::cout << to_int<res>::result << std::endl; // prints 10

	return 0;
}