Scala Rendimiento: estilo imperativo vs funcional

Question

Soy nuevo en Scala y solo estaba leyendo Scala By Example. En el capítulo 2, el autor tiene 2 versiones diferentes de Quicksort.

Uno de ellos es el estilo imperativo:

def sort(xs: Array[Int]) { 
    def swap(i: Int, j: Int) { 
     val t = xs(i); xs(i) = xs(j); xs(j) = t 
    } 
    def sort1(l: Int, r: Int) { 
     val pivot = xs((l + r)/2) 
     var i = l; var j = r 
     while (i <= j) { 
      while (xs(i) < pivot) i += 1 
      while (xs(j) > pivot) j -= 1 
      if (i <= j) { 
       swap(i, j) 
       i += 1 
       j -= 1 
      } 
     } 
     if (l < j) sort1(l, j) 
     if (j < r) sort1(i, r) 
    } 
    sort1(0, xs.length - 1) 
} 

Uno de ellos es el estilo funcional:

def sort(xs: Array[Int]): Array[Int] = { 
    if (xs.length <= 1) xs 
    else { 
    val pivot = xs(xs.length/2) 
    Array.concat(
     sort(xs filter (pivot >)), 
      xs filter (pivot ==), 
     sort(xs filter (pivot <))) 
    } 
} 

La ventaja obvia el estilo funcional tiene sobre el estilo imperativo es la concisión. ¿Pero qué hay del rendimiento? Dado que usa recursividad, ¿pagamos la penalización de rendimiento tal como lo hacemos en otros lenguajes imperativos como C? O, como Scala es un lenguaje híbrido, se prefiere el "modo Scala" (funcional), por lo tanto, más eficiente.

Nota: El autor mencionó que el estilo funcional usa más memoria.

Answer 1

Depende. Si mira en las fuentes de Scala, a menudo hay un estilo imperativo que se usa "debajo del capó" para ser un rendimiento, pero en muchos casos exactamente estos ajustes permiten escribir código funcional. Por lo general, puede encontrar una solución funcional que sea lo suficientemente rápida, pero debe tener cuidado y saber lo que hace (especialmente en lo que respecta a sus estructuras de datos). P.ej. la matriz concat en el segundo ejemplo no es agradable, pero probablemente no está mal, pero usar las listas aquí y concat con ellos sería demasiado.

Pero eso no es más que una conjetura educada si en realidad no mide el rendimiento. En proyectos complejos, es realmente difícil predecir el rendimiento, especialmente cuando cosas como la creación de objetos y las llamadas a métodos se optimizan cada vez más con el compilador y la JVM.

Sugiero comenzar con el estilo funcional. Si es demasiado lento, perfúlalo. Por lo general, hay una mejor solución funcional. De lo contrario, puede usar el estilo imperativo (o una combinación de ambos) como último recurso.