¿Quien soy?

• Programo en Java desde Java 1.1.
• Actualmente trabajo en https://clarity.ai como backender.
• Mi primera charla en una conferencia.

Agenda

• El largo camino a Java 21.
• Tipos de datos algebraicos.
• Ejemplos.
• Futuro.

Java Release Cadence

• Dos release al año.
• Preview features.
• They have a plan.

Switch expressions

• Incluido en Java 14.
• Una nueva vida para switch.
• Una gran mejora en general para el lenguage.

var value = switch (input) {
    case "a" -> 1;
    case "b" -> 2;
    default -> 0;
};

Records

• Incluido en Java 16.
• Muy esperado por la comunidad.
• Inmutables.

public record Movie(String title, int year, int duration) {

}

Sealed classes and interfaces

• Incluido en Java 17.
• Jerarquías de clases cerradas.

public sealed interface Shape {

    record Square(int side) implements Shape {}
    record Rectangle(int weight, int height) implements Shape {}
    record Circle(int radious) implements Shape {}

}

Pattern matching for switch

• Incluido en Java 21.
• Exhaustiveness.

var result = switch (obj) {
    case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format("double %f", d);
    case String s  -> String.format("String %s", s);
    default        -> obj.toString();
};

Record patterns

• Incluido en Java 21.
• Deconstructores, nos permite acceder a los componentes de los objectos.

var area = switch (shape) {
    case Square(var side) -> side * side;
    case Rectangle(var weight, var height) -> weight * height;
    case Circle(var radious) -> Math.PI * radious^2;
}

Tipos de datos algebraicos

• AKA ADTs (algebraic data types)
• Viene de las matemáticas.
• Productos y sumas de tipos.
• Recursivo.

Tipos de datos algebraicos (II)

• Podemos representarlos en Java.
• Un record es un producto de tipos.
• Un sealed interface es una suma de tipos.

public sealed interface Tree {

    record Node(String value, Tree left, Tree right) implements Tree { }
    record Leaf(String value) implements Tree {}

} 

Tipos de datos algebraicos (III)

• Podemos representar Optional con ADTs

public sealed interface Optional<T> {

    record Empty<T>() implements Optional<T> { }
    record Present<T>(T value) implements Optional<T> {}

} 

Ejemplo

• ¿Pero eso para qué me sirve?
• Manejo de errores.

Unnamed variables and patterns

• Incluido en Java 22.
• Mejora para el pattern matching.
• Eliminar verbosidad.

var result = switch (obj) {
    case Integer _ -> "int";
    case Long _    -> "long";
    case Double _  -> "double";
    case String _  -> "string";
    default        -> "other";
};

Primitive types in patterns

• Preview en Java 23 (sep 2024).

var result = switch (obj) {
    case int i -> String.format("int %d", i);
    case long l    -> String.format("long %d", l);
    case double d  -> String.format("double %f", d);
    case String s  -> String.format("String %s", s);
    default        -> obj.toString();
};

Derived Record Creation

• Draft.
• AKA withers.

Point newPoint = oldPoint with { 
    x *= 2; 
    y *= 2; 
};

Member patterns

• Early work.
• AKA deconstructors.
• Mejora para pattern matching.
• Cualquier clase.

¿Qué falta todavía?

• Tail recursion.
• Soporte de tipos de datos primitivos en genericos.

JEPs

• Switch expressions 14
• Records 16
• Sealed Classes and interfaces 17
• Pattern matching for switch 21
• Record patterns 21
• Unnamed variables and patterns 22
• Primitive types in patterns 23 (1st preview)