Java and Kotlin with Elide

Call a bundled language tool directly when you have one focused job, or use an Elide project when dependencies, tests, and outputs need to be shared. Both approaches use the same binary.

This project declares one Java entrypoint, mixed-language main and test source sets, and three publishable JAR artifacts. Java and Kotlin share the same source-set classpaths automatically.

amends "elide:project.pkl"import "elide:Jvm.pkl" as Jvmimport "elide:Sources.pkl" as Sources
name = "order-report"
jvm {  main = "shop.Main"}
sources {  ["main"] = new Sources.SourceSetSpec {    paths {      "src/main/kotlin/**/*.kt"      "src/main/java/**/*.java"    }  }  ["test"] = new Sources.SourceSetSpec {    paths {      "src/test/kotlin/**/*.kt"      "src/test/java/**/*.java"    }  }}
artifacts {  ["app"] = new Jvm.Jar {    name = "order-report"    main = "shop.Main"    sources { "main" }  }  ["sources"] = new Jvm.SourceJar {    sources { "main" }  }  ["docs"] = new Jvm.JavadocJar {    sources { "main" }  }}

The default build compiles non-test source sets and produces their configured artifacts. Tests compile against main outputs and execute with JUnit Platform.

elide project info       # Confirm the detected project and entrypointelide install            # Resolve declared Maven dependencieselide build --inspect    # List generated tasks and task optionselide build              # Compile main sources and produce default artifactselide test               # Compile tests and run them with JUnit Platformelide run                # Build as needed, then launch shop.Main

package shop
import java.math.BigDecimalimport kotlin.test.Testimport kotlin.test.assertEquals
class OrderTotalsTest {  @Test  fun `summarizes quantities and prices`() {    val summary = OrderTotals.summarize(      listOf(        LineItem("paper", 3, BigDecimal("7.50")),        LineItem("ink", 2, BigDecimal("18.25")),      ),    )
    assertEquals(5, summary.itemCount)    assertEquals(BigDecimal("59.00"), summary.subtotal)  }}

Elide also exposes the rest of its JVM toolchain directly. Prefix the familiar tool with elide, then put its native arguments after the separator.

• Run compiled classes

  Launch a JVM entrypoint with the bundled Java runtime.

  elide java -- -cp target app.Main

• Generate API docs

  Generate Javadoc using the standard command-line options.

  elide javadoc -- -d docs src/main/java/app/Main.java

• Inspect bytecode

  Disassemble a compiled class while debugging build output.

  elide javap -- -classpath target -c app.Main

• Build a native executable

  Compile a JVM application ahead of time with GraalVM Native Image.

  elide native-image -- -cp app.jar app.Main

This example puts a Kotlin model and calculation beside a Java entrypoint in one main source set. Elide compiles both languages, connects their classes, and runs the Java entrypoint.

package shop
import java.math.BigDecimal
data class LineItem(  val sku: String,  val quantity: Int,  val unitPrice: BigDecimal,)
data class OrderSummary(  val itemCount: Int,  val subtotal: BigDecimal,)
object OrderTotals {  @JvmStatic  fun summarize(lines: List<LineItem>): OrderSummary = OrderSummary(    itemCount = lines.sumOf { it.quantity },    subtotal = lines.fold(BigDecimal.ZERO) { total, line ->      total + line.unitPrice.multiply(line.quantity.toBigDecimal())    },  )}

package shop;
import java.math.BigDecimal;import java.util.List;
public final class Main {  public static void main(String[] args) {    var lines = List.of(        new LineItem("paper", 3, new BigDecimal("7.50")),        new LineItem("ink", 2, new BigDecimal("18.25")),        new LineItem("labels", 4, new BigDecimal("3.10"))    );
    var summary = OrderTotals.summarize(lines);
    System.out.printf(        "%d items · $%s subtotal%n",        summary.getItemCount(),        summary.getSubtotal()    );  }}