Haskell Language

  difSquare x y = (x-y)^2
  

  fact :: Integer -> Integer
  fact n
    | n < 0 = error "negative integer"
    | n == 0 =1
    | n > 0 = n * fact (n - 1)
  

  fact n
    | n < 0 = error "negative integer"
    | n == 0 =1
    | n > 0 = n * fact (n - 1)
  

  :type fact 8.0
  fact 8.0 :: (Ord a, Fractional a) => a

  :type fact 20
  fact 20 :: (ord a, Num a) => a

  :type fact
  fact :: (Num a, Ord a) => a -> a
  

  -- Factorial by primitive recursion on decreasing num 
  fac1 :: Int -> Int 
  fac1 n = if n==1 then 1 else (n * fac1 (n-1)) 
  

  -- Factorial by primitive recursion on list tail 
  fac2 :: Int -> Int 
  fac2 n = prodList [1 .. n] 
  prodList lst = 
    if (length lst)==1 then head lst 
    else head lst*(prodList (tail lst)) 
  

  i=[1,3 ..]
  

  square :: Int -> Int 
  square n = n*n 

  double :: Int ->Int 
  double n = n*2 

  dubSqr2 :: Int -> Int 
  dubSqr2 = square.double 
  

  [ (x,y) | x <- [1,3 ..], y <- [2,4 ..]]
  

  qsort []     = []
  qsort (x:xs) = qsort elts_lt_x ++ [x] ++ qsort elts_greq_x
                   where
                     elts_lt_x   = [y | y <- xs, y < x]
                     elts_greq_x = [y | y <- xs, y >= x]
  

  qsort( a, lo, hi ) int a[], hi, lo;
  {
    int h, l, p, t;
  
    if (lo < hi) {
      l = lo;
      h = hi;
      p = a[hi];

      do {
        while ((l < h) && (a[l] <= p)) 
            l = l+1;
        while ((h > l) && (a[h] >= p))
            h = h-1;
        if (l < h) {
            t = a[l];
            a[l] = a[h];
            a[h] = t;
        }
      } while (l < h);
  
      t = a[l];
      a[l] = a[hi];
      a[hi] = t;
 
      qsort( a, lo, l-1 );
      qsort( a, l+1, hi );
    }
  }