Nulo furtivo: rompiendo la opción Scala usando Java

Saludos, Habr! Les traigo un breve artículo del viernes sobre Java, Scala, programadores locos y promesas incumplidas.

Las observaciones simples a veces conducen a preguntas no muy simples.

Aquí, por ejemplo, hay un hecho simple y externo, tal vez incluso trivial, que establece que en Java puede extender cualquier clase no final y cualquier interfaz de alcance. Y otro, también bastante simple, que dice que el código Scala compilado para la JVM puede usarse a partir del código Java.

Sin embargo, la combinación de estos dos hechos me hizo preguntarme: ¿cómo se comportará cualquier clase desde el punto de vista de Java, que en Scala está sellado, es decir? no se puede expandir con código externo relativo a su propio archivo?

Scala-class descompuesta en la visión del artista. Fuente: https://specmahina.ru/wp-content/uploads/2018/08/razobrannaya-benzopila.jpg

Como conejo experimental, tomé la clase estándar Option. Al alimentarlo al descompilador integrado en IntelliJ Idea, obtenemos algo como esto:

//  ,     
public abstract class Option 
implements IterableOnce, Product, Serializable {
    //   
    public abstract Object get();
    //    
}

Sin embargo, el código descompilado no será un código Java válido, un problema similar al descrito aquí , por ejemplo, con este método:

public List toList() {
    return (List)(
        this.isEmpty() 
            ? scala.collection.immutable.Nil..MODULE$  
            : new colon(this.get(), scala.collection.immutable.Nil..MODULE$)
    );
}

MODULE$ , package object. , , Java , ?

, , ...

Java ( Maven), Scala provided- — , , , :

<dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>2.13.1</version>
    <scope>provided</scope>
</dependency>

, scala.Option. Idea, , Scala , sealed-, , , :

package hack;

public class Hacking<T> extends scala.Option<T> {
    @Override
    public T get() {
        return null;
    }

    public int productArity() {
        return 0;
    }

    public Object productElement(int n) {
        return null;
    }

    public boolean canEqual(Object that) {
        return false;
    }
}

- , Option Product.

, — . mvn package — , , jar-, , Java, , , .

, Scala.

… scala-

Scala (, SBT) — lib , , , ; build.sbt , Idea. ( ) :

import hack.Hacking

object Main {
  def main(args: Array[String]): Unit = {
    implicit val opt: Option[String] = new Hacking()
    //    
  }

  private def tryDo[T](action: => T): Unit = {
    try {
      println(action)
    } catch {
      case e: Throwable => println(e.toString)
    }
  }
}

implicit var .

tryDo — , : , , . call-by-name tryDo , , .

, match — , sealed class- ( , sealed-, ?)

object Main {
  def main(args: Array[String]): Unit = {
    // snip
    tryMatch
  }

  private def tryDo[T](action: => T): Unit = {
    // snip
  }

  private def tryMatch(implicit opt: Option[String]): Unit = tryDo {
    opt match {
      case Some(inner) => inner
      case None => "None"
    }
  }
}

:

scala.MatchError: hack.Hacking

, : Option — sealed class, ( case Some case None), :

[warn] $PATH/Main.scala:22:5: match may not be exhaustive.
[warn] It would fail on the following input: None
[warn]     opt match {
[warn]     ^

, .

, - Option:

object Main {
  def main(args: Array[String]): Unit = {
    // snip
    tryMap
  }

  private def tryDo[T](action: => T): Unit = {
    // snip
  }

  private def tryMap(implicit opt: Option[String]): Unit = 
    tryDo(opt.map(_.length))
}

:

java.lang.NullPointerException

, map:

sealed abstract class Option[+A] /* extends ... */ {
  //   . ,  None -  .
  final def isEmpty: Boolean = this eq None
  //  ,       null.
  def get: A
  // , ,  map.
  @inline final def map[B](f: A => B): Option[B] =
    if (isEmpty) None else Some(f(this.get))
}

, :

• — None. , isEmpty false.
• , this.get, null.
• null , — length.
• length null NPE.

, NPE , Java ? (, , , ...)

:

object Main {
  def main(args: Array[String]): Unit = {
    // snip
    tryContainsNull
  }

  private def tryDo[T](action: => T): Unit = {
    // snip
  }

  private def tryContainsNull(implicit opt: Option[String]): Unit =
    tryDo(opt.contains(null))
}

(, , null) , contains -Nullable . , , , Option false — null. ?

:

true

, , , contains map: !isEmpty && this.get == elem.

, . , null , Option ( , , ) else match.

De hecho, todo lo que se necesitaba para este artículo era un pequeño experimento para revelar un matiz de interacción entre diferentes idiomas en una JVM. El matiz, con un poco de reflexión, es obvio, pero, para mi gusto, sigue siendo interesante.