Un post rápido, comparando implementaciones de un algoritmo en su aproximación funcional e imperativa.

Cuando empezamos a programar, normalmente lo hacemos en un lenguaje imperativo, y el primer programa que tecleamos es nuestro querido "hola mundo". Bien, en el mundo funcional existe un equivalente al hola mundo que suele ser escribir una función que genere la serie de fibonacci, pero creo que será más interesante algo un poquito más complicado, usemos el quicksort:

1-pseudocódigo

 function quicksort(array)
      var list less, greater
      if length(array) ≤ 1  
          return array  
      select and remove a pivot value pivot from array
      for each x in array
          if x ≤ pivot then append x to less
          else append x to greater
      return concatenate(quicksort(less), pivot, quicksort(greater))

2.- C 

 void Quicksort(int[] v, int prim, int ult) {
         if (prim < ult) {
                 int p = Pivot(v, prim, ult, ult);
 
                 Quicksort(v, prim, p - 1);
                 Quicksort(v, p + 1, ult);
         }
 }
  
 int Pivot(int[] v, int prim, int ult, int piv) {
         int p = v[piv];
         int j = prim;
 
         swap(v, piv, ult);
  
         for (int i = prim; i < ult; i++) {
                 if (v[i] <= p) {
                         swap(v, i, j);
                         j++;
                 }
         }
         swap(v, j, ult);
  
         return j;
 }
  
 void swap(int[] v, int a, int b) {
         if (a != b) {
                 int tmp = v[a];
                 v[a] = v[b];
                 v[b] = tmp;
         }
 }

3.-Java

 public class QuickSort {
    public static void swap (int A[], int x, int y) {
       int temp = A[x];
       A[x] = A[y];
       A[y] = temp;
    }
                
    public static int partition(int A[], int f, int l) {
       int pivot = A[f];
       while (f < l) {
          while (A[f] < pivot) f++;
          while (A[l] > pivot) l--;
          swap (A, f, l);
       }
       return f;
    }
 
    public static void Quicksort(int A[], int f, int l) {
       if (f >= l) return;
       int pivot_index = partition(A, f, l);
       Quicksort(A, f, pivot_index);
       Quicksort(A, pivot_index+1, l);
    }
 }

4.-Clojure Lisp

 (defn qsort
   ([] [])
   ([x & xs] (concat (apply qsort (filter #(< % x) xs))
 		    (cons x (apply qsort (filter #(>= % x) xs))))))

5.-Haskell 

 qsort []     = []
 qsort (x:xs) = qsort smaller ++ [x] ++ qsort bigger
     where smaller = filter (<x)  xs
           bigger = filter (>=x) xs

Los ejemplos están sacados de wikipedia, menos el de Clojure Lisp. Lo dicho, busque, compare, etc.