Why Don’t They Just…​ ?!

record Customer(String name) {

    // no accessor
    private final String id;

    // [...]

}

if (range instanceof Range(int low, int high)
        && high < low)
    return new Range(high, low);

Range range = new Range(5, 10);
// SYNTAX IS MADE UP!
Range newRange = range with {
    low = 0;
}
// range: [5; 10]
// newRange: [0; 10]

int compute(String word) throws IOException;
int supercharge(int val) throws InterruptedException;

try {
    List<Integer> supercharged = Stream
        .of("foo", "bar")
        .map(this::compute)
        .map(this::supercharge)
        .toList();
} catch (IOException | InterruptedException ex) {
    // ...
}

interface Function<IN, OUT> {
    OUT apply(IN input) throws Exception;
}

interface Stream<E> {
    <OUT> Stream<OUT> map(Function<E, OUT> f)
    throws Exception;

    List<E> toList();
}

interface Function<IN, OUT> {
    OUT apply(IN input) throws Exception;
}

interface Stream<E> {
    <OUT> Stream<OUT> map(Function<E, OUT> f)

    List<E> toList() throws Exception;
}

try {
    List<Integer> supercharged = Stream
        .of("foo", "bar")
        .map(this::compute)
        .map(this::supercharge)
        .toList();
} catch (Exception ex) {
    // which exceptions?
}

List<Integer> supercharged = Stream
    .of("foo", "bar")
    .map(word -> word)
    // compile error: unhandled exception
    .toList();

interface Function<IN, OUT, EX extends Exception> {
    OUT apply(IN input) throws EX;
}

interface Stream<E, EX extends Exception> {
    <OUT, F_EX extends Exception>
    Stream<OUT, F_EX> map(Function<E, OUT, F_EX> f);

    List<E> toList() throws EX;
}

try {
    List<Integer> supercharged = Stream
        .of("foo", "bar")
        // ⇝ Stream<Integer, IOException>
        .map(this::compute)
        // ⇝ Stream<Integer, InterruptedException>
        .map(this::supercharge)
        .toList();
} catch (InterruptedException ex) {
    // good
} catch (IOException ex) {
    // isn't declared, so can't be caught
    // ⇝ compile error
}

static <
    IN, OUT,
    NEW_EX extends Exception,
    STREAM_EX extends NEW_EX,
    F_EX extends NEW_EX>
Stream<OUT, NEW_EX> map(
        Stream<IN, STREAM_EX> stream,
        Function<IN, OUT, F_EX> f) {
    // ...
}

try {
    List<Integer> supercharged = Stream
        // ⇝ Stream<Integer, IOException>
        .map(
            // ⇝ Stream<Integer, FileNotFoundException>
            Stream.map(
                // ⇝ Stream<String, RuntimeException>
                Stream.of("foo", "bar"),
                this::throwsFileNotFoundException),
            this::throwsZipException)
        .toList();
} catch (IOException ex) {
    // nice
}

try {
    List<Integer> supercharged = Stream
        // ⇝ Stream<Integer, Exception>
        .map(
            // ⇝ Stream<Integer, IOException>
            Stream.map(
                // ⇝ Stream<String, RuntimeException>
                Stream.of("foo", "bar"),
                this::compute),
            this::supercharge)
        .toList();
} catch (Exception ex) {
    // argh!
}

interface Stream<E> {

    <OUT, F_EX extends Exception>
    StreamEx1<OUT, F_EX>
    map(Function<E, OUT, F_EX> f);

    List<E> toList();
}

interface StreamEx1<E, EX extends Exception> {

    <OUT, F_EX extends Exception>
    StreamEx2<OUT, EX, F_EX>
    map(Function<E, OUT, F_EX> f);

    List<E> toList() throws EX;
}

interface StreamEx2<E,
        EX0 extends Exception,
        EX1 extends Exception> {

    <OUT, F_EX extends Exception>
    StreamExN<OUT> map(Function<E, OUT, F_EX> f);

    List<E> toList() throws EX0, EX1;
}

interface StreamExN<E> {

    <OUT, F_EX extends Exception>
    StreamExN<OUT> map(Function<E, OUT, F_EX> f);

    List<E> toList() throws Exception;
}

try {
    List<Integer> supercharged = Stream
        // ⇝ Stream<String>
        .of("foo", "bar")
        // ⇝ StreamEx1<Integer, IOException>
        .map(this::compute)
        // ⇝ StreamEx2<Integer, IOException,
        //             InterruptedException>
        .map(this::supercharge)
        .toList();
} catch (IOException ex) {
    // good
} catch (InterruptedException ex) {
    // great
}

interface Function<
        IN, OUT, EXs... extends Exception> {
    OUT apply(IN input) throws EXs;
}

interface Stream<E, EXs... extends Exception> {
    <OUT, F_EXs... extends Exception>
    Stream<OUT, EXs | F_EX>
    map(Function<E, OUT, F_EXs> f);

    List<E> toList() throws EXs;
}

try {
    List<Integer> supercharged = Stream
        // ⇝ Stream<String>
        .of("foo", "bar")
        // ⇝ Stream<Integer, IOException>
        .map(this::compute)
        // ⇝ Stream<Integer, IOException,
        //          InterruptedException>
        .map(this::supercharge)
        .toList();
} catch (InterruptedException ex) {
    // good
} catch (IOException ex) {
    // great
}

List<Integer> supercharged = Stream
    .of("foo", "bar")
    // ⇝ Stream<Try<Integer>>
    .map(this::compute)
    // ⇝ Stream<Try<Integer>>
    .map(this::supercharge)
    .toList();

List<Agent> agents = new ArrayList<>();
// compiles because `List` extends `ImmutableList`
ImmutableList<Agent> section4 = agents;
// prints nothing
section4.forEach(System.out::println);

// now lets mutate `section4`
agents.add(new Agent("Motoko"));
// prints "Motoko" - how did she get in here?!
section4.forEach(System.out::println);

interface SecretService {

    void payAgents(UnmodifiableList<Agent> agents);
    void sendOnMission(ImmutableList<Agent> agents);
    void downtime(List<Agent> agents);

    UnmodifiableList<Agent> teamRoster();
    ImmutableList<Agent> teamOnMission();
    List<Agent> team();

}

interface SecretService {

    void payAgents(List<Agent> agents);
    void sendOnMission(List<Agent> agents);
    void downtime(List<Agent> agents);

    List<Agent> teamRoster();
    List<Agent> teamOnMission();
    List<Agent> team();

}

// argh!
String street = null;
if (customer != null && customer.address() != null)
    street = customer.address().street();

// ugh
Optional<String> streetOpt = customerOpt
    .flatMap(Customer::address)
    .flatMap(Address::street);

// yay (?)
String street = customer?.address()?.street();

var street = customer?.address?.street

// this is a compile error
var street: String = customer?.address?.street
// need to declare `street` as nullable
var street: String? = customer?.address?.street

String? print(String! message) {
    // [...]
}

// compile errors
String! message = null;
print(null);
String! printed = print("foo");