¿Cuál es la diferencia entre llaves y soportes normales en RxJava con Kotlin?

No entiendo la diferencia real entre las llaves y los soportes normales en Kotlin cuando uso RxJava. Por ejemplo, tengo el siguiente código que funciona como se esperaba:

someMethodThatReturnsCompletable() .andThen(anotherMethodThatReturnsACompletable()) .subscribe(...) 

Pero lo siguiente NO funciona:

 someMethodThatReturnsCompletable() .andThen { anotherMethodThatReturnsACompletable() } .subscribe(...) 

Tenga en count la diferencia en la parte andThen() de la cadena con las llaves. No puedo entender cuál es la diferencia entre los dos. He echado un vistazo a algunos artículos, pero desafortunadamente sigo teniendo dificultades para entender esta sutil diferencia.

El primer segmento de código ejecuta anotherMethodThatReturnsACompletable() y pasa el valor de retorno a andThen() , donde se acepta un Completable como parámetro.

En el segundo segmento de código, está escribiendo una function literal como expresión lambda . Pasa una function de tipo () -> Unit a andThen() , que también es una statement válida, pero el código dentro de la lambda no se puede llamar.

En Kotlin, existe la convención de que si el último parámetro para una function es una function, y está pasando una expresión lambda como el argumento correspondiente, puede especificarlo fuera de paréntesis:

 lock (lock) { shanetworkingResource.operation() } 

Dado que Kotlin admite la conversión de SAM ,

Esto significa que los literales de function Kotlin se pueden convertir automáticamente en implementaciones de interfaces Java con un único método no pnetworkingeterminado, siempre que los types de parameters del método de interfaz coincidan con los types de parameters de la function Kotlin.

Mirando hacia atrás a Completable , hay varias andThen() sobrecargadas y andThen() :

 andThen(CompletableSource next) andThen(MaybeSource<T> next) andThen(ObservableSource<T> next) andThen(org.reactivestreams.Publisher<T> next) andThen(SingleSource<T> next) 

Aquí puede especificar el tipo de SAM llamando:

 andThen( CompletableSource { //implementations }) 

Como probablemente sepa, en Java () se usan corchetes para pasar parameters y {} llaves se usan para el cuerpo del método y también representa el cuerpo de la expresión lambda.

Así que vamos a comparar:

  1. .andThen(anotherMethodThatReturnsACompletable()) : aquí y el método Then () acepta Completable así y luego saveá la reference al completable devuelto por otro anotherMethodThatReturnsACompletable() para suscribirse más tarde.

  2. .andThen { anotherMethodThatReturnsACompletable() } : Esto pasa la expresión lambda al método andThen. Aquí no se invoca anotherMethodThatReturnsACompletable() en el momento de pasar el lambda. anotherMethodThatReturnsACompletable() cuando se invoque la function lambda en el método andThen.

Espero eso ayude.

.andThen(anotherMethodThatReturnsACompletable()) significa que el resultado de anotherMethodThatReturnsACompletable() pasará a andThen()

.andThen { anotherMethodThatReturnsACompletable() } significa que el lambda, que ejecuta anotherMethodThatReturnsACompletable() pasará a andThen()

() -> Estás pasando algo dentro de ellos, es decir, arguments de function

{} -> Estás ejecutando algo dentro de ellos. es decir, expresión

  • Cómo pasar nulo a un Observable con tipo anulable en RxJava 2 y Kotlin
  • Cómo crear el controller de respuesta genérica para el error y validar la respuesta utilizando retrofit, rxjava y dagger
  • ¿Cómo puedo indicar explícitamente la finalización de un Flowable en RxJava?
  • RxJava Debounce onNext ()
  • Convirtiendo un Observable en un Flujo con contrapresión en RxJava2
  • Manejo de errores de suscripción anidada RX2.0
  • No se puede llamar al operador desde () en Observable en Android Kotlin
  • RxJava salida diferente entre Flowable y Observable con window y Groupby
  • ¿Cómo puedo fusionar una sola <Lista <Lista <T >>> en una Lista <T> con RxJava 2?
  • Cómo recordar el estado con los operadores de rebashs en RxJava2
  • Referencia de constructor de Kotlin con generics