Java 23

/**md
 *
 * Markdown here...
 *
 */

/**md
 *
 * Here's a list:
 *
    * item #1
    * item #1
 *
 */

/**md
 *
 * ```java
 * /* a Java inline comment */
 * ```
 *
 */

int x = 0;
if (x instanceof byte b)
	System.out.println(b + " in [-128, 127]");
else
	System.out.println(x + " not in [-128, 127]");

int x = 16_777_216;
if (x instanceof float f)
	// use `f`

Boolean bool = // ...
var emoji = switch (bool) {
	case null -> ""
	case true -> "✅";
	case false -> "❌";
}

// option A
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// option B
import java.util.*;

import module $mod;

import module $mod;

import module java.base;
import module java.desktop;
import module java.sql;

public class Example {

	public void example() {
		// error: reference to Date is ambiguous
		var outdated = new Date(1997, 1, 18);
		// error: reference to List is ambiguous
		var letters = List.of("I", "J", "N");
	}

}

import module java.base;
import module java.desktop;
import module java.sql;

import java.util.Date;
import java.util.List;

public class Example {

	public void example() {
		var outdated = new Date(1997, 1, 18);
		var letters = List.of("I", "J", "N");
	}

}

// complete Main.java - no explicit imports!
void main() {
	List<?> dates = Stream
		.of(1, 2, 23, 29)
		.map(BigDecimal::new)
		.map(day -> LocalDate.of(
			2024,
			RandomGenerator.getDefault()
				.nextInt(11) + 1,
			day.intValue()))
		.toList();

	System.out.println(dates);
}

public sealed interface Page
	permits GitHubIssuePage, GitHubPrPage,
			ExternalPage, ErrorPage {
	// ...
}

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ExternalPage ext -> categorizeExternal(ext);
		case ErrorPage err -> categorizeError(err);
	}
}

public void categorize(Page page) {
	// error:
	//     "the switch statement does not cover
	//      all possible input values"
	switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ExternalPage ext -> categorizeExternal(ext);
		case ErrorPage err -> categorizeError(err);
	}
}

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		default -> { }
	}
}

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		// duplication 😢
		case ErrorPage err -> { };
		case ExternalPage ext -> { };
	};
}

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ErrorPage _, ExternalPage _ -> { };
	};
}

// create `Arena` to manage off-heap memory lifetime
try (Arena offHeap = Arena.ofConfined()) {
	// [allocate off-heap memory to store pointers]
	// [do something with off-heap data]
	// [copy data back to heap]
} // off-heap memory is deallocated here

String[] javaStrings = { "mouse", "cat", "dog" };
// Arena offHeap = ...

MemorySegment pointers = offHeap.allocateArray(
	ValueLayout.ADDRESS, javaStrings.length);
for (int i = 0; i < javaStrings.length; i++) {
	// allocate off-heap & store a pointer
	MemorySegment cString = offHeap
		.allocateUtf8String(javaStrings[i]);
	pointers
		.setAtIndex(ValueLayout.ADDRESS, i, cString);
}

// String[] javaStrings = ...
// MemorySegment pointers =

for (int i = 0; i < javaStrings.length; i++) {
	MemorySegment cString = pointers
		.getAtIndex(ValueLayout.ADDRESS, i);
	javaStrings[i] = cString.getUtf8String(0);
}

// find foreign function on the C library path
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();
MethodHandle radixSort = linker
	.downcallHandle(stdlib.find("radixsort"), ...);

String[] javaStrings = { "mouse", "cat", "dog" };
try (Arena offHeap = Arena.ofConfined()) {
	// [move Java strings off heap]
	// invoke foreign function
	radixSort.invoke(
		pointers, javaStrings.length,
		MemorySegment.NULL, '\0');
	// [copy data back to heap]
}

// smallest viable Main.java
void main() {
	// ...
}

// complete Main.java
void main() {
	var letters = List.of("A", "B", "C");
	println(letters);
}

java Main.java

MyFirstJava
 ├─ Main.java
 ├─ Helper.java
 └─ Lib
     └─ library.jar

java -cp 'Lib/*' Main.java

String property = "last_name";
String value = "Doe";

// concatenation
String query =
	"SELECT * FROM Person p WHERE p."
		+ property + " = '" + value + "'";
// formatting
String query =
	"SELECT * FROM Person p WHERE p.%s = '%s'"
		.formatted(property, value);

// (fictional syntax!)
String query =
	"SELECT * FROM Person p "
		+ "WHERE p.\{property} = '\{value}'";

Statement query = SQL."""
	SELECT * FROM Person p
	WHERE p.\{property} = '\{value}'
	""";

class Name {

	private final String first;
	private final String last;

	Name(String first, String last) {
		// [... checks for null, etc. ...]
		this.first = first;
		this.last = last;
	}

	Name(String last) {
		this("", last);
	}

}

class ThreePartName extends Name {

	private final String middle;

	ThreePartName(
			String first, String middle, String last) {
		// doesn't compile without this call
		super(first, last);
		this.middle = middle;
	}

}

class Name {

	// fields and constructor as before

	Name(String full) {
		// does the same work twice
		this(
			full.split(" ")[0],
			full.split(" ")[1]);
	}

}

class Name {

	// fields and constructor as before

	// avoids two splits but "costs"
	// duplicated argument validation
	Name(String full) {
		String[] names = full.split(" ");
		// [... checks for null, etc. ...]
		this.first = names[0];
		this.last = names[1];
	}

}

class Name {

	// fields and constructor as before

	// avoids two splits but "costs"
	// an additional constructor
	Name(String full) {
		this(full.split(" "));
	}

	private Name(String[] names) {
		this(names[0], names[1]);
	}

}

class Name {

	// fields and constructor as before

	// avoids two splits but "costs"
	// an additional construction protocol
	static Name fromFullName(String full) {
		String[] names = full.split(" ");
		return new Name(names[0], names[1]);
	}

}

record Name(String first, String last) {

	// nope
	Name(String full) {
		String[] names = full.split(" ");
		// [... checks for null, etc. ...]
		this.first = names[0];
		this.last = names[1];
	}

}

record Name {

	Name(String full) {
		String[] names = full.split(" ");
		this(names[0], names[1]);
	}

}

class ThreePartName extends Name {

	private final String middle;

	ThreePartName(
			String first, String middle, String last) {
		// can't have a middle name without a first name
		requireNonNullNonEmpty(first);
		super(first, last);
		this.middle = middle;
	}

}

class ThreePartName extends Name {

	private final String middle;

	ThreePartName(
			String first, String middle, String last) {
		// shorten first if middle is given
		var short1st = middle.length() == 1
				? first.substring(0, 1)
				: first;
		super(first, last);
		this.middle = middle;
	}

}

class ThreePartName extends Name {

	private final String middle;

	ThreePartName(String full) {
		// split "first middle last" on space (once 🙌🏾)
		var names = full.split(" ");
		super(names[0], names[2]);
		this.middle = names[1];
	}

}

static <T> Gatherer<T, ?, T> transparent() {
	Integrator<Void, T, T> integrator = (_, el, ds)
		-> ds.push(el);
	return Gatherer.of(integrator);
}

static <T, R> Gatherer<T, ?, R> map(Function<T, R> f) {
	Integrator<Void, T, R> integrator = (_, el, ds) -> {
		R newEl = f.apply(el);
		return ds.push(newEl);
	};
	return Gatherer.of(integrator);
}

Supplier<List<T>> initializer = ArrayList::new;

Integrator<List<T>, T, List<T>> integrator =
	(list, el, ds) -> {
		list.add(el);

		if (list.size() < size)
			return true;
		else {
			var group = List.copyOf(list);
			list.clear();
			return ds.push(group);
		}
	};

BiConsumer<List<T>, Downstream<List<T>>> finisher =
	(list, ds) -> {
		var group = List.copyOf(list);
		ds.push(group);
	};

static <T> Gatherer<T, ?, List<T>> groups(int size) {
	Supplier<...> initializer = // ...
	Integrator<...> integrator = // ...
	BiConsumer<...> finisher = // ...

	return Gatherer.ofSequential(
		initializer, integrator, finisher);
}

Stream.of("A", "C", "F", "B", "S")
	.gather(groups(2))
	.forEach(System.out::println);

// [A, C]
// [F, B]
// [S]