Quote:Original post by snk_kid

Quote:Original post by Nitage
How would you add a member function that sets the matrix to the identity matrix? In C++, you'd have to duplicate the entire class definition, using partial specialization to pick out square matrices (the only kind of matrices that have identity matrices).

Well not quite, it's not true it's just the most obvious solution but it's not the only one. I can think of two methods that don't require (partial) specialization.

1.

#include <cstddef>#include <boost/utility/enable_if.hpp>#include <boost/mpl/equal_to.hpp>#include <boost/mpl/size_t.hpp>namespace mpl = boost::mpl;template < std::size_t M, std::size_t N >matrix<M, N>& identity(matrix<M, N>& m,                       typename boost::enable_if<                           mpl::equal_to<                               mpl::size_t<M>,                               mpl::size_t<N>                            >                        >::type* = 0) { /*<-insert-code->*/}

2.

//.... just imagine headers herenamespace mpl = boost::mpl;using namespace boost::mpl::placeholders;template < typename Matrix >struct sqr_matrix {    Matrix& identity() {          Matrix& this_ = static_cast<Matrix&>(*this);          //.......          return this_;    }    // add all other ops that are only for square matrix};template < std::size_t M, std::size_t N >struct matrix    : mpl::if_<          mpl::equal_to<              mpl::size_t<M>,              mpl::size_t<N>          >,          sqr_matrix< matrix<M, N> >,          mpl::empty_base       >::type{ .... };

Quote:Original post by Drakex

Quote:Does anyone have some code that shows D doing something better than C++ or at least being done in a less complicated fashion?

Alright then. This is a trivial example, but demonstrates a few key issues: operator overloading, templates, classes, and overall syntax:

#include <iostream>         //the .h headers are deprecated#include <vector>           //STL is part of the standard libraryusing namespace std;        //just for the sake of this exampleint main(int argc, char** argv){	for(int i = 0; i < argc; i++)		cout << "Arg " << i << " = " << argv << endl;	vector<int> c(10);	c[4] = 5;	c[6] = 10;	cout << "Length: " << c.size() << endl;	cout << c[4] << ", " << c[6] << endl;        for(vector<int>::iterator i = c.begin(); i != c.end(); i++)    //this loop was present in the D version, but not the C++ version; I took the liberty of adding it                cout << *i;	c.clear();}        // 0 no longer needs to be explicitly returned

Quote:Original post by Anthony Serrano(...) If you want to show D doing something better or simpler than C++, might I suggest an example that uses features of D that are not trivially duplicated in C++?

Quote:
How do D templates fare with something much more significant, like a regular expression compiler? Eric Niebler has written one for C++ that relies on expression templates. [4] The problem with using expression templates is that one is restricted to using only C++ operator syntax and precedence. Hence, regular expressions using expression templates don't look like regular expressions, they look like C++ expressions. Eric Anderton has written one for D that relies on the ability of templates to parse strings. [5] This means that, within the strings, one can use the expected regular expression grammar and operators.

The regex compiler templates parse the regex string argument, pulling off tokens one by one from the front, and instantiating custom template functions for each token predicate, eventually combining them all into one function that directly implements the regular expression. It even gives reasonable error messages for syntax errors in the regular expression.

Calling that function with an argument of a string to match returns an array of matching strings:

import std.stdio;
import regex;

void main()
{
auto exp = &regexMatch!(r"[a-z]*\s*\w*");
writefln("matches: %s", exp("hello world"));
}

Quote:Original post by Anthony SerranoIf you want to show D doing something better or simpler than C++, might I suggest an example that uses features of D that are not trivially duplicated in C++?