Haskell-inspired quick sort in ES6

quicksort.hs

quicksort :: (Ord a) => [a] -> [a]    
quicksort [] = []    
quicksort (x:xs) =     
    let smallerSorted = quicksort (filter (<=x) xs)  
        biggerSorted = quicksort (filter (>x) xs)   
    in  smallerSorted ++ [x] ++ biggerSorted

quicksort.js

/* 
1) passing array
   > quicksort([4,3,2,1]); // => [1,2,3,4]
*/
function quicksort(tail) {
  if (tail.length === 0) return [];
  let head = tail.splice(0, 1)[0];
  return quicksort(tail.filter( _ => _ <= head))
         .concat([head])
         .concat(quicksort(tail.filter( _ => _ > head )))
}

/* 
2) via arguments
   > quicksort(4,3,2,1); // => [1,2,3,4]
   or:
   > quicksort(...[4,3,2,1]); // => [1,2,3,4]
*/
function quicksort(x, ...xs) {
  if (arguments.length === 0) return [];
  return quicksort(...xs.filter( _ => _ <= x))
         .concat([x])
         .concat(quicksort(...xs.filter( _ => _ > x )))
}

I like this one :)

const quicksort = array => {
    if (array.length === 0) return [];
    let [x, ...xs] = array;    
    return [
        ...quicksort(xs.filter(y => y < x)),
        x,
        ...quicksort(xs.filter(y => y >= x))
    ];
};

One issue is performance since you are filtering the same array twice

function quickSort(values = []) {
  const [pivot, ...restValues] = values;
  
  if (!pivot) return [];
  if (!restValues.length) return [pivot];
  
  const [lesser, greater] = restValues.reduce((partitions, val) => {    
    partitions[+(val > pivot)].push(val);

    return partitions;
  }, [[], []]);
  
  return [
    ...quickSort(lesser),
    pivot,
    ...quickSort(greater),
  ];
}