Performance Scala: Imperativo VS Estilo funcional

Question

Soy nuevo en Scala y solo estaba leyendo Scala por ejemplo .En el Capítulo 2, el autor tiene 2 versiones diferentes de Quicksort.

uno es un 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 es un 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 concisince.Pero ¿qué pasa con el rendimiento?Dado que utiliza la recursión, ¿pagamos la penalización de desempeño como lo hacemos en otros idiomas imperativos como C?O, Scala es un lenguaje híbrido, se prefiere la "manera de Scala" (funcional), por lo tanto, más eficiente.

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

Answer 1

depende. Si se fijan en las fuentes de Scala, a menudo hay un estilo imperativo usado "bajo la capucha" para ser actuador, pero en muchos casos exactamente estos ajustes lo permiten usted Escribir rendimiento funcional código. Por lo general, generalmente puede crear una solución funcional que sea lo suficientemente rápida, pero debe tener cuidado y saber qué hace (especialmente con respecto a sus estructuras de datos). P.ej. La matriz que se conceja en el segundo ejemplo no es agradable, pero probablemente no esté tan mal, pero usando listas aquí y concatalas con :::: sería exagerado.

Pero eso no es más que adivinanza educado si en realidad no está el rendimiento. En proyectos complejos, es muy difícil predecir el rendimiento, especialmente cuando las cosas como la creación de objetos y las llamadas del método obtienen más y más optimizadas por el compilador y el JVM.

Me sugiero que comience con el estilo funcional. Si es demasiado lento, lo perfil. Por lo general, hay una solución mejor funcional. Si no, puede usar el estilo imperativo (o una mezcla de ambos) como último recurso.