Introducing record pattern for switch – Record and record pattern

93. Introducing record pattern for switch

You already know that type patterns can be used for instanceof and switch expressions. This statement is true for record patterns as well. For instance, let’s reiterate the Doctor and Resident records:

public record Doctor(String name, String specialty)
  implements Staff {}
public record Resident(String name, Doctor doctor)
  implements Staff {}

We can easily use these two records via record patterns in a switch expression as follows:

public static String cabinet(Staff staff) {
 return switch(staff) {
  case Doctor(var name, var specialty)
    -> “Cabinet of ” + specialty + “. Doctor: ” + name;
  case Resident(var rsname, Doctor(var drname, var specialty))
    -> “Cabinet of ” + specialty + “. Doctor: “
                     + drname + “, Resident: ” + rsname;
  default -> “Cabinet closed”;
 };
}

Adding references to records themselves as binding variables is straightforward:

return switch(staff) {
  case Doctor(String name, String specialty) dr
    -> “Cabinet of ” + dr.specialty()
                     + “. Doctor: ” + dr.name();
  case Resident(String rsname,
       Doctor(String drname, String specialty) dr ) rs
    -> “Cabinet of ”  + dr.specialty() + “. Doctor: “
         + dr.name() + “, Resident: ” + rs.name();
  default -> “Cabinet closed”;
};

Adding more nested records follows the same principle. For instance, let’s add the Patient and Appointment records as well:

public record Appointment(LocalDate date, Doctor doctor) {}
public record Patient(
  String name, int npi, Appointment appointment) {}

Now, we can write the following beauty:

public static String reception(Object o) {
              
  return switch(o) {         
    case Patient(String ptname, int npi,
         Appointment(LocalDate date,
         Doctor (String drname, String specialty))) ->
           “Patient ” + ptname + ” (NPI: ” + npi
              + “) has an appointment at “
              + date + ” to the doctor ” + drname + ” (“
              + specialty + “).”;
    default -> “”;
  };
}

And, adding references to records should have no secrets.

return switch(o) {
  case Patient(String ptname, int npi,
       Appointment(LocalDate date,
       Doctor (String drname, String specialty) dr) ap) pt ->
         “Patient ” + pt.name() + ” (NPI: ” + pt.npi()
            + “) has an appointment at “
            + ap.date() + ” to the doctor ” + dr.name()
            + ” (” + dr.specialty() + “).”;
  default -> “”;
};

Notice that the topics covered in Chapter 2 such as dominance, completeness, and unconditional patterns remain valid for record patterns with switch as well. Actually, there are some important things to highlight about unconditional patterns, but that is covered later in Problem x.