marp: true title: Una mirada funciona a Java 22 theme: gaia footer: #commitconf 2024 author: Antonio Muñoz color: #fff transition: fade-out

backgroundImage: url('https://cdn.wallpapersafari.com/97/99/MnWulT.jpg')

Una mirada funcional a Java

Antonio Muñoz

¿Quien soy?

Programo en Java desde Java 1.1.
Actualmente trabajo en https://clarity.ai como backender.
Mi primera charla en una conferencia.
Me encontraréis en:
- Mastodon: @tonivade@jvm.social
- Github: https://github.com/tonivade

Encuesta

Java 22?
Java 21?
Java 17?
Java 11?
Todavía Java 8?
Y anteriores a Java 8? :exploding_head:

Jetbrains ecosystem survey

¿Qué versión de Java usáis regularmente?
Todavía el 50% usan Java 8 regularmente.

Java 8

Lanzado en Marzo 2014
No existía ni tiktok ni openai :robot:
Ese mismo año se lanzó spring-boot v1.0.
Docker y kubernetes daban sus primeros pasos.

Agenda

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

Java Release Cadence

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

Switch expressions :railway_track:

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

Incluido en Java 14.
Una nueva vida para switch.
Expresión.

Records

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

Incluido en Java 16.
Muy esperado por la comunidad.
Inmutables.
Constructor canónico.

Records: Constructor Canónico

public record Movie(String title, int year, int duration) {
    public Movie {
        if (title == null || title.isEmpty()) {
            throw new IllegalArgumentException();
        }
    }
}

Se ejecuta siempre.

Sealed classes and interfaces

public sealed interface Shape {
    record Square(int side) implements Shape {}
    record Rectangle(int weight, int height) implements Shape {}
    record Circle(int radius) implements Shape {}
}

Incluido en Java 17.
Jerarquías de clases cerradas.
non-sealed

non-sealed

public sealed interface Shape {
    record Square(int side) implements Shape {}
    record Rectangle(int weight, int height) implements Shape {}
    record Circle(int radius) implements Shape {}
    non-sealed interface CustomShape extends Shape {}
}

Pattern matching for switch

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();
};

Incluido en Java 21.

Record patterns

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

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

Guarded patterns

var result = switch (point) {
    case Point(var x, var y) when y == 0 -> processX(x);
    case Point(var x, var y) -> processXY(x, y);
};

Podemos añadir condiciones adicionales usando when

Unnamed variables and patterns

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

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

Tipos de datos algebraicos

AKA ADTs (algebraic data types).
Viene de las matemáticas.
Recursivo.

Otros lenguajes con soporte ADTs

Scala, Kotlin
Rust
C#

ADTs

Productos y sumas de tipos. a + b a * b
Cardinalidad.
Se les llama algebraicos porque tienen propiedades algebraicas.

ADTs

Propiedades algebraicas:
- Identidad: a + 0 <=> a a * 1 <=> a
- Distributiva: (a * b) + (a * c) <=> a * (b + c)
- Conmutativa: a * b <=> b * a a + b <=> b + a
- Asociativa: a + b + c <=> a + (b + c) a * b * c <=> a * (b * c)

ADTs

¿Cómo podemos representarlos en Java?
Un record es un producto de tipos.
Un sealed interface es una suma de tipos.
¿Pero eso para qué me sirve?

ADTs: List

sealed interface List<T> {

    record NonEmpty<T>(T head, List<T> tail) implements List<T> {}

    record Empty<T>() implements List<T> {}
}

ADTs: List (map)

sealed interface List<T> {

    default <R> List<R> map(Function<T, R> mapper) {
        return switch (this) {
            case NonEmpty<T>(var head, var tail)
                -> new NonEmpty<>(mapper.apply(head), tail.map(mapper));
            case Empty<T>()
                -> new Empty<>();
        };
    }
}

ADTs: List (filter)

sealed interface List<T> {

    default List<T> filter(Predicate<T> filter) {
        return switch (this) {
            case NonEmpty<T>(var head, var tail) when filter.test(head)
                -> new NonEmpty<>(head, tail.filter(filter));
            case NonEmpty<T>(var head, var tail)
                -> tail.filter(filter);
            case Empty<T>()
                -> new Empty<>();
        };
    }
}

ADTs: List (fold)

sealed interface List<T> {

    default T fold(T initial, BinaryOperator<T> operator) {
        return switch (this) {
            case NonEmpty<T>(var head, var tail)
                -> tail.fold(operator.apply(initial, head), operator);
            case Empty<T>()
                -> initial;
        };
    }
}

ADTs: Tree

sealed interface Tree<T> {

    record Node<T>(T value, Tree<T> left, Tree<T> right) implements Tree<T> { }

    record Leaf<T>(T value) implements Tree<T> {}
}

ADTs: Optional

sealed interface Optional<T> {

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

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

ADTs: Optional (map)

sealed interface Optional<T> {

    default <R> Optional<R> map(Function<T, R> mapper) {
        return switch (this) {
            case Present<T>(var value) -> new Present<>(mapper.apply(value));
            case Empty<T> _ -> new Empty<>();
        };
    }
}

ADTs: Optional (filter)

sealed interface Optional<T> {

    default Optional<T> filter(Predicate<T> filter) {
        return switch (this) {
            case Present<T>(var value) when filter.test(value) -> this;
            case Present<T> _ -> new Empty<>();
            case Empty<T> _ -> new Empty<>();
        };
    }
}

ADTs: Optional (fold)

sealed interface Optional<T> {

    default <R> R fold(Supplier<R> onEmpty, Function<T, R> onPresent) {
        return switch (this) {
            case Present<T>(var value) -> onPresent.apply(value);
            case Empty<T> _ -> onEmpty.get();
        };
    }
}

ADTs: Either

sealed interface Either<L, R> {

    record Left<L, R>(L left) implements Either<L, R> { }

    record Right<L, R>(R right) implements Either<L, R> {}
}

ADTs: Json

sealed interface Json {
    enum JsonNull implements Json { NULL }
    enum JsonBoolean implements Json { TRUE, FALSE }
    record JsonString(String value) implements Json {}
    record JsonNumber(Number value) implements Json {}
    record JsonObject(Map<String, Json> value) implements Json {}
    record JsonArray(List<Json> value) implements Json {}
}

ADTs: Errores

interface MovieRepository {
    MovieResponse create(Movie movie);
}

sealed interface MovieResponse permits MovieCreated, MovieError {}

record MovieCreated(UUID id) implements MovieResponse {}

ADTs: Errores

sealed interface MovieError extends MovieResponse {
    record DuplicatedMovie(UUID id) implements MovieError {}
    record InvalidDuration(int duration) implements MovieError {}
    record InvalidYear(int year) implements MovieError {}
    record InvalidStars(int stats) implements MovieError {}
    record EmptyTitle() implements MovieError {}
    record EmptyDirector() implements MovieError {}
    record EmptyCast() implements MovieError {}
    record DuplicatedActor(String actor) implements MovieError {}
}

ADTs: Either

interface MovieRepository {
    Either<MovieCreated, MovieError> create(Movie movie);
}

Próximamente

Primitive types in patterns

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();
};

Preview en Java 23 (sep 2024).

Primitive types in patterns

jshell> int i = 0;
i ==> 0
jshell> i instanceof byte b
$2 ==> true

jshell> int i = 123213;
i ==> 123213
jshell> i instanceof byte b
$4 ==> false

Castings seguros

Bola de cristal

Derived Record Creation

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

Draft.
AKA withers.

Static patterns

var result = switch (optional) {
    case Optional.of(var value) -> value.toString();
    case Optional.empty() -> "empty";
};

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

Constant patterns

var result = switch (optional) {
    case Point(0, var y) -> process(y);
    case Point(var x, var y) -> process(x, y);
};

¿Qué falta todavía?

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

¿Preguntas?

¡Gracias!

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)
Derived record creation Candidate

backgroundImage: url('https://cdn.wallpapersafari.com/97/99/MnWulT.jpg')

Una mirada funcional a Java

¿Quien soy?

Encuesta

Jetbrains ecosystem survey

Java 8

Agenda

Java Release Cadence

Switch expressions :railway_track:

Records

Records: Constructor Canónico

Sealed classes and interfaces

non-sealed

Pattern matching for switch

Record patterns

Guarded patterns

Unnamed variables and patterns

Tipos de datos algebraicos

Otros lenguajes con soporte ADTs

ADTs

ADTs

ADTs

ADTs: List

ADTs: List (map)

ADTs: List (filter)

ADTs: List (fold)

ADTs: Tree

ADTs: Optional

ADTs: Optional (map)

ADTs: Optional (filter)

ADTs: Optional (fold)

ADTs: Either

ADTs: Json

ADTs: Errores

ADTs: Errores

ADTs: Either

Próximamente

Primitive types in patterns

Primitive types in patterns

Bola de cristal

Derived Record Creation

Static patterns

Constant patterns

¿Qué falta todavía?

¿Preguntas?

¡Gracias!

JEPs

Links