When dealing with nested Objects in Java –
Something like:

// bad code
game.getPlayer().getState().getPositionInfo().getCurrent().getX();

, it is not clear if a nested reference would return null resulting in a NullPointerException to be thrown.

My idea was to have one generic method which calls reference path down while checking for a null reference,
and instead of throwing the Exception, just return null.

Error handling is out of scope for this solution.

My minimum code example looks like this:

import java.util.function.Function;

public class Main {

    public static void main(String[] args) {
        // Check 1: baseline - "normal" function mappings
        SAVE.TY_Baseline(b -> b.contains("a"), "aoiudssaiud"); // works

        // Check 2: nested types
        Team t = new Team(new Team(null));
        Team t1 = SAVE.TY_Chained(() -> t.getTeam(), z -> z.getTeam()); // does not compile

        // Check 3: String -> boolean -> String
        String g = "Hi !";
        // does not compile
        Team t2 = SAVE.TY_Chained(() -> g.contains("Hi"), b -> b ? "contained" : "not contained"); 
    }

    public static class Team {
        private Team t = null;
        public Team(Team t) {
            this.t = t;
        }
        public Team getTeam() {
            return t;
        }
    }

    public static interface SAVE {
        public static <A, B> B TY_Chained(Function<Void, A> first , Function<A, B> second) {
            A firstResult = first.apply(null);
            if (firstResult == null)
                return null;
            return second.apply(firstResult);
        }
        public static <A,B> B TY_Baseline(Function<A,B> oo, A in) {
            return oo.apply(in);
        }
    }
}

For check 1:
Everything turns out good, the function executes and the compiler recognizes the input as String and also accepts the function.

For check 2 and 3:
When chaining the functions, the compiler does not know which parameter type function “second” has and will not accept this method call.
Getting:

java: incompatible types: incompatible parameter types in lambda expression

Using OpenJDK V22 right now.