JDK 24: added example of Module Import and Scoped Value

Author: wesleyegberto

java-24/ModuleImportDeclarationsTest.java

@@ -0,0 +1,17 @@
+import module java.base;
+import module java.sql;
+import module java.desktop;
+
+import java.util.*; // priori List
+import java.util.Date;
+
+/**
+ * Run: `java --source 24 --enable-preview ModuleImportDeclarationsTest.java`
+ */
+public class ModuleImportDeclarationsTest {
+	public static void main(String[] args) {
+		Date date = new Date();
+
+		List l = new ArrayList();
+	}
+}

java-24/README.md

@@ -113,7 +113,8 @@ To run each example use: `java --enable-preview --source 24 <FileName.java>`
 * **Scoped Values**
     * re-preview with API changes
     * removed methods `callWhere` and `runWhere` to make API more fluent
-    * `ScopedValue.where(SCOPE, "my-value").run(() -> {});` instead of `ScopedValue.callWhere(SCOPE, "my-value", () -> {})`
+    * `ScopedValue.where(SCOPE, "my-value").run(() -> {});` instead of `ScopedValue.runWhere(SCOPE, "my-value", () -> {})`
+    * `ScopedValue.where(SCOPE, "my-value").call(() -> {});` instead of `ScopedValue.callWhere(SCOPE, "my-value", () -> {})`
     * we can bind multiples values:
         * `ScopedValue.where(SCOPE_A, "my-value").where(SCOPE_B, "other-value").run(() -> {})`
 * **Primitive Types in Patterns, instanceof, and switch**
@@ -151,6 +152,8 @@ To run each example use: `java --enable-preview --source 24 <FileName.java>`
 * **Simple Source Files and Instance Main Methods**
     * re-preview with no change
     * introduced new terminology "simple source file" to indicate a Java file with a implicitly declared class
+* **Structured Concurrency**
+    * 
 
 ## Links
 

java-24/ScopedValueUsageExample.java

@@ -0,0 +1,79 @@
+
+import java.util.concurrent.*;
+
+/**
+ * Run: `java --source 24 --enable-preview ScopedValueUsageExample.java`
+ */
+public class ScopedValueUsageExample {
+	final static ScopedValue<String> MAIN_SCOPE = ScopedValue.newInstance();
+
+	public static void main(String[] args) {
+		System.out.println("Starting scoped value");
+
+		// we can share a value from here
+		ScopedValue.where(MAIN_SCOPE, "message from main")
+			.run(() -> {
+				var worker = new Worker();
+				worker.execute();
+			});
+		System.out.println("main ending");
+	}
+}
+
+class Worker {
+	final static ScopedValue<String> WORKER_SCOPE = ScopedValue.newInstance();
+
+	public void execute() {
+		// accessing the value from the scope
+		System.out.println("shared value from main: " + ScopedValueUsageExample.MAIN_SCOPE.get());
+
+		// === Nested Scope ===
+		// we can create a nested scope
+		ScopedValue.where(WORKER_SCOPE, "message from worker")
+				.run(() -> {
+					// the outmost scope will still works
+					var messageFromMain = ScopedValueUsageExample.MAIN_SCOPE.get();
+					var messageFromWorker = WORKER_SCOPE.get();
+					System.out.println("shared value to inner scope from main: " + messageFromMain);
+					System.out.println("shared value to inner scope from worker: " + messageFromWorker);
+				});
+
+		// we cannot access it from outside its scope (NoSuchElementException)
+		// var invalidAccess = WORKER_SCOPE.get();
+
+		// === Rebinded Scope Value ===
+		// we can create a new scope that rebinds a new value to the created scope (when using the same variable)
+		ScopedValue.where(ScopedValueUsageExample.MAIN_SCOPE, "message from worker over main")
+				.run(() -> {
+					// the outmost scope will still works
+					var rebindedMessage = ScopedValueUsageExample.MAIN_SCOPE.get();
+					System.out.println("shared value from shadowed scope: " + rebindedMessage);
+				});
+
+		// but the original scope from main will still have its initial value (immutable)
+		System.out.println("shared value from main after all scopes: " + ScopedValueUsageExample.MAIN_SCOPE.get());
+
+		// === Failure Handle ===
+		try {
+			// with `where` we get checked exception type inference (requiring try-catch block)
+			var result = ScopedValue.where(WORKER_SCOPE, "message for a risk move")
+					.call(() -> {
+						var message = WORKER_SCOPE.get();
+
+						if (message.length() > 15) {
+							throw new MessageTooLongException();
+						}
+						return 42;
+					});
+			System.out.println("Result from risk move: " + result);
+		} catch (MessageTooLongException ex) {
+			System.err.println("Error during risk move: " + ex.getMessage());
+		}
+	}
+}
+
+class MessageTooLongException extends Exception {
+	MessageTooLongException() {
+		super("Message provided in the scope was too long");
+	}
+}