You're assuming the same program/function/class would be implemented in same way across different languages, or at least in a way that would be easily comparable. And that there's one 'correct' way to implement something per language. Using that site as an example, what's the benefit of comparing the following?
Code:
quicksort [] = []
quicksort (s:xs) = quicksort [x|x <- xs,x < s] ++ [s] ++ quicksort [x|x <- xs,x >= s]
Code:
def quicksort(arr):
if len(arr) <= 1: return arr
m = arr[0]
return quicksort(filter(lambda i,j=m: i<j, arr)) + \
filter(lambda i,j=m: i==j, arr) + \
quicksort(filter(lambda i,j=m: i>j, arr))
Code:
template <class itemType, class indexType=int>
void QuickSort(itemType a[], indexType l, indexType r)
{
static itemType m;
static indexType j;
indexType i;
if(r > l) {
m = a[r]; i = l-1; j = r;
for(;;) {
while(a[++i] < m);
while(a[--j] > m);
if(i >= j) break;
std::swap(a[i], a[j]);
}
std::swap(a[i],a[r]);
QuickSort(a,l,i-1);
QuickSort(a,i+1,r);
}
}
The second (Python) example could equally have been written procedurally/iteratively/imperatively like the third (C++) example, as well as the current recursive functional-like version which is more similar to the first (Haskell) example.
