Using Java from Scala

[warn] With --server=false, .java files are not compiled to .class files.
scalac parses .java sources for type information (cross-compilation), but without the build server (Bloop/Zinc) nothing compiles them to bytecode.
Remove --server=false or compile Java files separately to avoid runtime NoClassDefFoundError.

javac -d out Surface.java Waypoint.java Shape.java Registry.java
scala run --server=false --extra-jar out .

//> using scala 3.10.0

import java.util.{ArrayList, HashMap, List as JList, Map as JMap}
import scala.jdk.CollectionConverters.*

def javaTrails(): JList[String] =
  val l = new ArrayList[String]()
  l.add("Ridge"); l.add("Pico"); l.add("Lake")
  l

@main def run(): Unit =
  val jl = javaTrails()
  val sl: List[String] = jl.asScala.toList        // copy to an immutable List
  println(sl)
  val buf = jl.asScala                             // a live view: mutable.Buffer
  println(buf.getClass.getName)
  buf += "Col"
  println(jl)                                      // the Java list sees the change
  val jm = new HashMap[String, Int]()
  jm.put("Ridge", 8); jm.put("Pico", 12)
  val sm = jm.asScala.toMap
  println(sm.toList.sortBy(_._1))
  val back: JMap[String, Int] = Map("a" -> 1, "b" -> 2).asJava
  println(back.getClass.getName)
  try back.put("c", 3) catch case e: UnsupportedOperationException => println("immutable view: " + e.getClass.getSimpleName)
  println(List(1, 2, 3).asJava.getClass.getName)
  val it = jl.iterator().asScala
  println(it.map(_.toUpperCase).mkString(","))
  for t <- jl.asScala do println(t)

List(Ridge, Pico, Lake)
scala.collection.convert.JavaCollectionWrappers$JListWrapper
[Ridge, Pico, Lake, Col]
List((Pico,12), (Ridge,8))
scala.collection.convert.JavaCollectionWrappers$MapWrapper
immutable view: UnsupportedOperationException
scala.collection.convert.JavaCollectionWrappers$SeqWrapper
RIDGE,PICO,LAKE,COL
Ridge
Pico
Lake
Col

//> using scala 3.10.0
import java.util.ArrayList

@main def run(): Unit =
  val jl = new ArrayList[String]()
  jl.add("a")
  for s <- jl do println(s)

-- [E008] Not Found Error: F.scala:7:11
7 |  for s <- jl do println(s)
  |           ^^
  |value foreach is not a member of java.util.ArrayList[String] - did you mean jl.forEach?
1 error found

//> using scala 3.10.0
import java.util.{ArrayList, Comparator, Collections, HashMap}
import scala.jdk.CollectionConverters.*

@main def run(): Unit =
  val jl = new ArrayList[String]()
  jl.add("pico"); jl.add("ridge"); jl.add("lake")
  val cmp: Comparator[String] = (a, b) => a.length - b.length
  Collections.sort(jl, cmp)
  println(jl)
  jl.sort(Comparator.comparing[String, Integer](_.length).reversed())
  println(jl)
  jl.removeIf(_.startsWith("l"))
  println(jl)
  val m = new HashMap[String, Int]()
  m.merge("a", 1, _ + _)
  m.merge("a", 1, _ + _)
  m.computeIfAbsent("b", _ => 10)
  println(m.asScala.toList.sorted)
  for e <- m.entrySet().asScala.toList.sortBy(_.getKey) do println(s"${e.getKey} -> ${e.getValue}")
  val ints: Array[Int] = Array(3, 1, 2)
  java.util.Arrays.sort(ints)
  println(ints.toList)

[pico, lake, ridge]
[ridge, pico, lake]
[ridge, pico]
List((a,2), (b,10))
a -> 2
b -> 10
List(1, 2, 3)

// Surface.java
package trailhead;

public enum Surface {
    GRAVEL("gravel", 1.0), ROCK("rock", 1.5), SNOW("snow", 2.0);

    private final String label;
    private final double effort;

    Surface(String label, double effort) { this.label = label; this.effort = effort; }

    public String label() { return label; }
    public double effort() { return effort; }
}

// Waypoint.java
package trailhead;

public record Waypoint(String name, int elevationM) {
    public Waypoint {
        if (elevationM < 0) throw new IllegalArgumentException("negative elevation");
    }
    public static Waypoint summit(String name) { return new Waypoint(name, 3000); }
}

// Shape.java
package trailhead;

public sealed interface Shape permits Shape.Circle, Shape.Rect {
    record Circle(double r) implements Shape {}
    record Rect(double w, double h) implements Shape {}
}

// Registry.java
package trailhead;

import java.util.*;

public class Registry {
    public static final int MAX = 5;
    public static int created = 0;
    private final Map<String, Waypoint> byName = new LinkedHashMap<>();
    public Registry() { created++; }
    public void add(Waypoint w) { byName.put(w.name(), w); }
    public Waypoint find(String name) { return byName.get(name); }          // may return null
    public String note() { return null; }
    public List<Waypoint> all() { return new ArrayList<>(byName.values()); }
    public int size() { return byName.size(); }
    public static String describe(String sep, String... parts) { return String.join(sep, parts); }
    public static <T extends Comparable<T>> T max(List<? extends T> xs) {
        T best = null;
        for (T x : xs) if (best == null || x.compareTo(best) > 0) best = x;
        return best;
    }
}

//> using scala 3.10.0

import trailhead.*
import scala.jdk.CollectionConverters.*

def area(s: Shape): Double = s match
  case Shape.Circle(r)  => math.Pi * r * r
  case Shape.Rect(w, h) => w * h

@main def run(): Unit =
  val s = Surface.ROCK
  println((s, s.label, s.effort, s.ordinal, s.name))
  println(Surface.values.toList)
  println(Surface.valueOf("SNOW"))
  val label = s match
    case Surface.GRAVEL => "easy"
    case Surface.ROCK   => "careful"
    case Surface.SNOW   => "gear"
  println(label)
  val w = Waypoint("Pico", 2500)
  println(w)
  println(w.name + " " + w.elevationM)
  w match
    case Waypoint(n, e) if e > 2000 => println(s"$n is high")
    case Waypoint(n, _)             => println(s"$n is low")
  println(Waypoint.summit("Peak"))
  println(area(Shape.Circle(1.0)))
  println(area(Shape.Rect(2, 3)))
  val reg = Registry()
  reg.add(w)
  println(reg.size)       // no parentheses needed for a Java method
  println(reg.size())
  println(Registry.MAX)
  println(Registry.describe("-", "a", "b", "c"))
  println(Registry.describe("-"))
  val arr = Array("x", "y")
  println(Registry.describe("+", arr*))
  println(Registry.max(List[Integer](3, 9, 4).asJava))
  println(reg.find("Nope"))
  println(reg.note())
  println(Option(reg.note()).getOrElse("(none)"))
  try Waypoint("bad", -1) catch case e: IllegalArgumentException => println(e.getMessage)

(ROCK,rock,1.5,1,ROCK)
List(GRAVEL, ROCK, SNOW)
SNOW
careful
Waypoint[name=Pico, elevationM=2500]
Pico 2500
Pico is high
Waypoint[name=Peak, elevationM=3000]
3.141592653589793
6.0
1
1
5
a-b-c

x+y
2
null
null
(none)
negative elevation

//> using scala 3.10.0
import trailhead.*

def area(s: Shape): Double = s match
  case Shape.Circle(r) => math.Pi * r * r

def level(s: Surface): String = s match
  case Surface.GRAVEL => "easy"
  case Surface.ROCK   => "careful"

-- [E029] Pattern Match Exhaustivity Warning: M.scala:4:29
4 |def area(s: Shape): Double = s match
  |                             ^
  |                    match may not be exhaustive.
  |
  |                    It would fail on pattern case: _: trailhead.Shape.Rect
-- [E029] Pattern Match Exhaustivity Warning: M.scala:7:32
7 |def level(s: Surface): String = s match
  |                                ^
  |                                match may not be exhaustive.
  |
  |                                It would fail on pattern case: SNOW
2 warnings found

// Scorer.java
package trailhead;

@FunctionalInterface
public interface Scorer<T> {
    int score(T item);
    default Scorer<T> twice() { return t -> 2 * score(t); }
    static <T> Scorer<T> constant(int n) { return t -> n; }
}

// Planner.java
package trailhead;

import java.util.List;
import java.util.function.Function;

public abstract class Planner {
    protected final String name;
    public int visits;
    protected Planner(String name) { this.name = name; }
    public abstract String plan(List<String> stops);
    public String banner() { return "Planner " + name; }
    public <T> int total(List<T> xs, Scorer<? super T> s) {
        int sum = 0;
        for (T x : xs) sum += s.score(x);
        return sum;
    }
    public String apply(Function<String, String> f, String s) { return f.apply(s); }
    public void run(Runnable r) { r.run(); }
}

// Gate.java
package trailhead;

public interface Gate {
    boolean open();
    default String status() { return open() ? "open" : "closed"; }
}

//> using scala 3.10.0

import trailhead.*
import java.util.List as JList
import scala.jdk.CollectionConverters.*

class RidgePlanner(n: String) extends Planner(n):
  override def plan(stops: JList[String]): String =
    s"$name: ${stops.asScala.mkString(" -> ")}"
  override def banner(): String = super.banner() + "!"

class Lock(var locked: Boolean) extends Gate:
  def open(): Boolean = !locked

@main def run(): Unit =
  val p = RidgePlanner("R")
  println(p.plan(List("a", "b").asJava))
  println(p.banner())
  p.visits += 1
  println(p.visits)
  // anonymous implementations
  val g = new Gate:
    def open() = true
  println(g.status())
  println(Lock(true).status())

R: a -> b
Planner R!
1
open
closed

// Tag.java
package trailhead;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Tag {
    String value();
    int priority() default 0;
    String[] aliases() default {};
}

//> using scala 3.10.0
import trailhead.*

@Tag("trail")
class Annotated:
  @Tag(value = "m", priority = 2, aliases = Array("x", "y"))
  def m(): Unit = ()

@main def run(): Unit =
  val t = classOf[Annotated].getAnnotation(classOf[Tag])
  println((t.value, t.priority, t.aliases.toList))
  val tm = classOf[Annotated].getMethod("m").getAnnotation(classOf[Tag])
  println((tm.value, tm.priority, tm.aliases.toList))

(trail,0,List())
(m,2,List(x, y))

//> using scala 3.10.0
import trailhead.*
@main def run(): Unit =
  val reg = Registry()
  val n: String = reg.note()
  println(n)
  println(n.length)

null
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "n" is null
	at N$package$.run(N.scala:7)
	at run.main(N.scala:3)

//> using scala 3.10.0
import trailhead.*
import java.util.List as JList

class Lock(var locked: Boolean) extends Gate:
  def open(): Boolean = !locked

class Alarm:
  def ring(): String = "ring"
  override def toString(): String = "alarm"

class Banner(n: String) extends Planner(n):
  def plan(stops: JList[String]): String = "p"
  override def banner(): String = "b"

@main def run(): Unit =
  val reg = Registry()
  println(reg.size)            // Java method: ok
  println(reg.toString.length) // Object method: ok
  val l = Lock(false)
  println(l.open)              // Scala override of Java method: ok
  println(Banner("x").banner)  // Scala override of Java method: ok
  val a = Alarm()
  println(a.toString)          // overrides Object.toString: ok
  println(a.ring)              // plain Scala method: error

-- [E100] Syntax Error: A.scala:25:12
25 |  println(a.ring)
   |          ^^^^^^
   |          method ring in class Alarm must be called with () argument
   |
   | longer explanation available when compiling with `-explain`
1 error found

// Reader.java
package trailhead;

import java.io.IOException;

public class Reader {
    public String read(String path) throws IOException {
        if (path.isEmpty()) throw new IOException("empty path");
        return "data:" + path;
    }
}

//> using scala 3.10.0
import trailhead.*
import scala.util.Try

@main def run(): Unit =
  val r = Reader()
  println(r.read("f"))                      // no try needed
  try r.read("") catch case e: java.io.IOException => println("caught " + e.getMessage)
  println(Try(r.read("")))                  // turn the exception into a value
  println(r.read(""))                       // not caught: propagates

data:f
caught empty path
Failure(java.io.IOException: empty path)
Exception in thread "main" java.io.IOException: empty path
	at trailhead.Reader.read(Reader.java:7)
	at T$package$.run(T.scala:10)
	at run.main(T.scala:5)

//> using scala 3.10.0
import java.util.concurrent.{Callable, Executors}
import scala.jdk.CollectionConverters.*
import scala.util.Using

@main def run(): Unit =
  val tasks: List[Callable[String]] = List("a", "b", "c").map(s => (() => s.toUpperCase): Callable[String])
  Using.resource(Executors.newVirtualThreadPerTaskExecutor()) { ex =>
    val results = ex.invokeAll(tasks.asJava).asScala.map(_.get()).toList
    println(results)
  }
  val t = Thread.ofVirtual().start(() => println("virtual: " + Thread.currentThread().isVirtual))
  t.join()
  val r: Runnable = () => println("runnable")
  r.run()
  println(String.format("%s has %d trails", "Pico", 3))
  println("%s has %d trails".format("Pico", 3))

List(A, B, C)
virtual: true
runnable
Pico has 3 trails
Pico has 3 trails