¿Qué es una "representación elevada"?

No estoy familiarizado con la API de flujo.

El término "levantamiento" proviene de la teoría de categorías. En lenguajes de programación como Haskell o Scala, una función lift toma una función A => B , y de alguna manera realiza magia para que la función levantada F[A] => F[B] pueda aplicarse a un functor o mónada F[A] .

Un ejemplo concreto utilizando el contenedor Seq de Scala: Supongamos que tenemos una función def double(x: Int): Int = 2 * x y una secuencia val xs = Seq(1, 2, 3) . No podemos double(xs) debido a tipos incompatibles. Pero si obtenemos un val doubleSeq = liftToSeq(double) , podemos hacer doubleSeq(xs) , que se evalúa como Seq(2, 4, 6) . Aquí, liftToSeq se puede implementar como

def liftToSeq[A, B](f: A => B): (Seq[A] => Seq[B]) =
  (seq: Seq[A]) => seq.map(f)

El constructor Seq(…) también se puede ver como una operación de elevación, que eleva los valores 1, 2, 3 a una instancia Seq , lo que nos permite utilizar abstracciones de lista para estos valores.

Las mónadas nos permiten encapsular el funcionamiento interno de algún tipo al ofrecer una interfaz impermeable pero compostable. El uso de una representación elevada puede facilitar el razonamiento de un cálculo. El uso de tales abstracciones también significa que perdemos el conocimiento de las características específicas abstraídas, pero que son necesarias para proporcionar una implementación eficiente bajo el capó (encontrar una representación de ejecución adecuada).

El término to lift puede, por supuesto, tener diferentes significados según el contexto.

En programación genérica describe el proceso de abstraer al siguiente nivel superior. Por ejemplo, podría tener dos piezas de código, un tipo con int y el otro con float . Eliminar este código significaría algo así como crear una plantilla del método con un tipo genérico T que funciona para ambos, int y float .

Encontré que este uso del término es una buena guía intuitiva para lo que significa levantar . La única diferencia que parece existir entre los diferentes contextos es lo que realmente es esta abstracción superior.

En particular, Viktor es conocido en el contexto de la programación funcional y, en este contexto, puede encontrar diferentes interpretaciones de levantar allí. Un ejemplo es levantar los valores en un funtor, o levantar las funciones para que funcionen con valores monádicos (es decir, liftM2 de Haskell).

Un ejemplo muy concreto de una "representación elevada" podría entonces f.ex. ser un List(1) o un Some(1) .

Este tipo de conceptos suele ser más fácil de entender con un ejemplo concreto. Considere el siguiente extracto de este Ejemplo de API de flujo :

Flow(text.split("\s").toVector).
      // transform
      map(line => line.toUpperCase).
      // print to console (can also use ''foreach(println)'')
      foreach(transformedLine => println(transformedLine)).
      onComplete(FlowMaterializer(MaterializerSettings())) {
        case Success(_) => system.shutdown()
        case Failure(e) =>
          println("Failure: " + e.getMessage)
          system.shutdown()
      }

Esto toma el siguiente código:

text.split("\s").toVector.
      map(line => line.toUpperCase).
      foreach(println)

y "lo eleva" a un contexto Flow . Eso le permite usar la misma sintaxis con la que está familiarizado para especificar su algoritmo, pero detrás de la escena, map se realiza en paralelo en varios procesadores o incluso máquinas, luego foreach(println) recopila sin problemas esa salida en un solo procesador para impresión.

Este es un término genérico que puede referirse a envolver cualquier contexto alrededor de cualquier tipo. Otro ejemplo más familiar es que map toma una función que funciona en un solo elemento y la "eleva" al nuevo contexto de trabajar en una colección de esos elementos. El levantamiento es ubicuo en la programación funcional y una de las razones principales es que es mucho más fácil reutilizar el código funcional.