Java

Consider a typical Java "Hello, world" program:

import java.lang.System;

class Main {
	public static void main(String[] args) {
		System.out.println("Hello, world!");
	}
}

To translate it directly to Keen:

An import beginning with java/ imports a class from the Java standard library.
(Replace . with /. So java/io/PrintStream imports java.io.PrintStream .)

Keen is not Java and doesn't have many of Java's features, such as classes and methods.
When Keen imports a Java class, the class' public properties and methods are translated to functions.

• A static field becomes a function with no arguments. The class name is omitted.
  For example, Java's System.out becomes out in Keen.
• A static method can be called directly. The class name is omitted.
  For example, Java's Math.sqrt becomes sqrt in Keen.
• An instance field becomes a function taking the class as an argument.
  For example, Java's Point.x instance field becomes a function x in Keen.
• For an instance method, a this argument of the class' type is prepended to the arguments.
  For example, the instance method println takes a java/io/PrintStream (such as out) as its first argument.
• A class constructor becomes a function named new, and a function named the same as the class. (Use whichever you prefer.)

All functions that come from Java have the java, global, and unsafe specs.

In Java, methods on a class can be called anywhere without importing the class. Keen doesn't work like that; if you want to call a method, you need to import the class.
The Java program above only needed import java.lang.System;, while the Keen version needs to import both java/io/PrintStream and java/lang/System.

In Java, all reference types have a null value.
Keen considers null values to be unsafe, so don't don't mark a call to a function that comes from Java as trusted unless you are sure it won't return null.

java-null is an unsafe function returning a Java null value for a type.
As a convenience, is-null a is equivalent to reference-equal a, java-null.

The below example reads a directory, handling the case where it does not exist.

Java subclasses implicitly convert to their superclasses (and interfaces).

For reference types, reinterpret-cast corresponds to a Java cast.
This can be used to convert a Java class to a subclass.

Keen supports Java generic types such as List.

Java types translate to the following Keen types:

Since Java Arrays are mutable, they are translated as buffer instead of array.
If a Java method treats an Array argument as read-only. you could use cast-mutable to pass in a Keen array.
If a Java method returns an Array that will never be mutated, you could use cast-immutable to get it as a Keen array.

There are additional functions in keen/unsafe for converting between types that have the same runtime representation, such as char8 buffer and nat8[]. (These work in any target, not just Java.)

Keen record types can implement Java interfaces directly. It works just like implementing a Keen interface.

Keen doesn't make use of Java generics, so:

• Java's sort function acts on an Object buffer .
• The interface is just Comparator with no type parameter.
• The comparator accepts Object parameters and downcasts them using reinterpret-cast.

A nested class like Map.Entry is imported as Map$Entry. The name of the type is just Entry.

There are no guarantees about how Keen translates to Java.
A Keen interface isn't always a Java interface.
A Keen record isn't always a Java record.
So don't expect to use Java reflection.

To use Java classes from outside the standard library, they must be in a JAR file.
The imports section of config.kid supports JAR files. (See "config.kid".)
For example:

With the above configuration, all imports starting with org/foo will resolve to classes from libs/foo.jar.

When you build the program, all classes (even ones not directly referenced) from configured JAR files will be copied to the output, so it builds to a standalone executable JAR.