Che cos'è una "rappresentazione sollevata"?

Non ho familiarità con l'API Flow.

Il termine "sollevamento" deriva dalla teoria delle categorie. Nei linguaggi di programmazione come Haskell o Scala, una funzione lift prende una funzione A => B , e in qualche modo esegue la magia in modo che la funzione sollevata F[A] => F[B] possa essere applicata a un functor o a una% di F[A] .

Un esempio concreto che utilizza il contenitore Seq di Scala: supponiamo di avere una funzione def double(x: Int): Int = 2 * x e una sequenza val xs = Seq(1, 2, 3) . Non possiamo double(xs) a causa di tipi incompatibili. Ma se otteniamo un val doubleSeq = liftToSeq(double) , possiamo fare doubleSeq(xs) , che valuta Seq(2, 4, 6) . Qui, liftToSeq può essere implementato come

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

Il costruttore Seq(…) può anche essere visto come un'operazione di sollevamento, che solleva i valori 1, 2, 3 in un'istanza Seq , consentendoci quindi di utilizzare le astrazioni elenco per questi valori.

Le Monade ci permettono di incapsulare i meccanismi interni di qualche tipo offrendo un'interfaccia stagna ma componibile. L'uso di una rappresentazione sollevata può rendere più facile ragionare su un calcolo. L'uso di tali astrazioni significa anche che perdiamo la conoscenza delle specifiche astratte, ma quelle sono necessarie per fornire un'efficiente implementazione sotto il cofano (trovare una rappresentazione di esecuzione adeguata).

Il termine da sollevare può ovviamente avere significati diversi a seconda del contesto.

Nella programmazione generica descrive il processo di astrazione al livello superiore successivo. Ad esempio, potresti avere due parti di codice, un tipo con int e l'altro con float . Sollevare questo codice significherebbe qualcosa come la templatura del metodo con un tipo generico T che funziona per entrambi, int e float .

Ho trovato questo uso del termine come una buona guida intuitiva per ciò che significa lifting . L'unica differenza che sembra esistere tra i diversi contesti è ciò che questa astrazione più alta è realmente.

In particolare, Viktor è conosciuto nel contesto della programmazione funzionale, e in questo contesto, puoi trovare visivamente diverse interpretazioni di sollevamento lì. Un esempio è il sollevamento di valori in un functor o il sollevamento di funzioni per lavorare su valori monadici (ad esempio Haskell liftM2 ).

Un esempio molto concreto di una "rappresentazione sollevata" potrebbe quindi f.ex. essere un List(1) o un Some(1) .

Questi tipi di concetti sono solitamente più facili da capire con un esempio concreto. Considera il seguente estratto da questo esempio dell'API di flusso :

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()
      }

Questo richiede il seguente codice:

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

e "lo alza" in un contesto Flow . Ciò ti consente di utilizzare la stessa sintassi che hai familiarità con la specifica dell'algoritmo, ma dietro le quinte il map viene eseguito in parallelo su diversi processori o anche su macchine, quindi foreach(println) raccoglie perfettamente quell'output su un processore per stampa.

Questo è un termine generico che può riferirsi a qualsiasi contesto attorno a qualsiasi tipo. Un altro esempio più familiare è map che prende una funzione che funziona su un singolo elemento e la "solleva" nel nuovo contesto di lavorare su una raccolta di quegli elementi. Il sollevamento è onnipresente nella programmazione funzionale e uno dei motivi principali per cui è molto più facile riutilizzare il codice funzionale.