{"id":1652,"date":"2021-03-14T14:29:32","date_gmt":"2021-03-14T13:29:32","guid":{"rendered":"https:\/\/benjiweber.co.uk\/blog\/?p=1652"},"modified":"2021-03-14T14:29:34","modified_gmt":"2021-03-14T13:29:34","slug":"java-16-pattern-matching-fun","status":"publish","type":"post","link":"https:\/\/benjiweber.co.uk\/blog\/2021\/03\/14\/java-16-pattern-matching-fun\/","title":{"rendered":"Java 16 Pattern Matching Fun"},"content":{"rendered":"\n

Java 16 brings Pattern Matching for instanceof<\/a>. It’s a feature with exciting possibilities, though quite limited in its initial incarnation. <\/p>\n\n\n\n

Basic Pattern Matching<\/h2>\n\n\n\n

We can now do things like <\/p>\n\n\n\n

Object o = \"hello\";\nif (o instanceof String s) {\n    System.out.println(s.toUpperCase());\n}<\/pre>\n\n\n\n
Note the variable “s”, which is then used without any casting needed.<\/p>\n\n\n\n
Deconstructing Optionals<\/h2>\n\n\n\n
It would be even nicer if we could deconstruct structured types at the same time. I think it’s coming in a future version, but I’m impatient. Let’s see how close we can get with the current tools.<\/p>\n\n\n\n
One thing we can do is use a function on the left hand side of this expression.<\/p>
 Let’s consider the example of dealing with unknown values in Java. There’s a fair amount of legacy to deal with. Sometimes you’ll get a value, sometimes you’ll get a null. Sometimes you’ll get an Optional<T><\/span> , sometimes you’ll get an Optional<Optional<T>><\/span> etc.<\/p>\n\n\n\n
How can we make unknowns nicer to deal with?<\/h3>\n\n\n\n
We could create a little utility function that lets us convert all of these forms of unknown into either a value or not. Then match with an instanceof test.<\/p>\n\n\n\n
Object unknown = Optional.of(\"Hello World\");\nassertEquals(\n       \"hello world\",\n       unwrap(unknown) instanceof String s\n               ? s.toLowerCase()\n               : \"absent\"\n);<\/pre>\n\n\n\n
Thanks to instanceof pattern matching we can just use the string directly, without having to resort to passing method references i.e optional.map(String::toLowercase)<\/span>\u00a0<\/p>\n\n\n\n
The unwrap utility itself uses pattern matching against Optional to recursively unwrap values from nested optionals. It also converts nulls and Optional.empty()<\/span> to a non-instantiatable type for the purposes of ensuring they can never match the above pattern.<\/p>\n\n\n\n
static Object unwrap(Object o) {\n   if (o instanceof Optional opt) {\n       return opt.isPresent() ? unwrap(opt.get()) : None;\n   } else if (o != null) {\n       return o;\n   } else {\n       return None;\n   }\n}\nstatic class None {\n   private None() {}\n   public static final None None = new None();\n}<\/pre>\n\n\n\n
Here’s several more examples<\/a>, if you’d like to explore further.<\/p>\n\n\n\n
Deconstructing Records<\/h2>\n\n\n\n
What about more complex structures? Now that we have record types<\/a>, wouldn’t it be great if we can deconstruct them to work with individual components more easily. I think until more powerful type patterns exist in the language we’ll have to diverge from the instanceof<\/span> approach. <\/p>\n\n\n\n
I previously showed how we could do this for records we control<\/a>, by having them implement an interface. What about records we do not control? How can we deconstruct those?\u00a0<\/p>\n\n\n\n
This is about the closest I can get to what I’d hope would be possible as a first class citizen in the language in future.<\/p>\n\n\n\n
record Name(String first, String last) {}\nObject name = new Name(\"Benji\", \"Weber\");\nIf.instance(name, (String first, String last) -> {\n   System.out.println(first.toLowerCase() + last.toLowerCase()); \/\/ prints benjiweber\n});\n<\/pre>\n\n\n\n
It takes a record (Name) and a lambda where the method parameters are of the same types as the component types in the record. It deconstructs the record component parts and passes them to the lambda to use (assuming the record really matches).<\/p>\n\n\n\n
We could also use as an expression to return a value, as long as we provide a fallback for the case when the pattern does not match.<\/p>\n\n\n\n
Object zoo = new Zoo(new Duck(\"Quack\"), new Dog(\"Woof\"));\n\nString result = withFallback(\"Fail\").\n    If.instance(zoo, (Duck duck, Dog dog) ->\n       duck.quack() + dog.woof()\n    ); \/\/ result is QuackWoof<\/pre>\n\n\n\n
So how does this work? <\/h3>\n\n\n\n
If.instance<\/span> is a static method which takes an Object<\/span> of unknown type (we hope it will be a Record<\/span>), and a lambda function that we want to pattern match against the provided object.<\/p>\n\n\n\n
How can we use a lambda as a type pattern? We can use the technique from my lambda type references<\/a> article\u2014have the lambda type be a SerializableLambda<\/a> which will allow us to use reflection to read the types of each parameter. <\/p>\n\n\n\n
static  void instance(Object o, MethodAwareTriConsumer action) { \n\n}<\/pre>\n\n\n\n
So we start with something like the above, a method taking an object and a reflectable lambda function.<\/p>\n\n\n\n
Next we can make use of pattern matching again to check if it’s a record.<\/p>\n\n\n\n
static  void instance(Object o, MethodAwareTriConsumer action) {\n   if (o instanceof Record r) {\n\t\/\/ now we know it's a record\n   }\n}<\/pre>\n\n\n\n
Records allow reflection on their component parts. Let’s check whether we have enough component parts to match the pattern.<\/p>\n\n\n\n
static  void instance(Object o, MethodAwareTriConsumer action) {\n   if (o instanceof Record r) {\n       if (r.getClass().getRecordComponents().length < 3) {\n           return;\n       }\n       \n\t \/\/ at this point we have a record with enough components and can use them.\n   }\n}<\/pre>\n\n\n\n
Now we can invoke the passed action itself <\/p>\n\n\n\n
action.tryAccept((T) nthComponent(0, r), (U) nthComponent(1, r), (V) nthComponent(2, r));<\/pre>\n\n\n\n
Where nthComponent<\/span> uses reflection to access the relevant component property of the record.<\/p>\n\n\n\n
private static Object nthComponent(int n, Record r)  {\n   try {\n       return r.getClass().getRecordComponents()[n].getAccessor().invoke(r);\n   } catch (Exception e) {\n       throw new RuntimeException(e);\n   }\n}<\/pre>\n\n\n\n
tryAccept<\/span> is a helper default method I've added in MethodAwareTriConsumer<\/span>. It checks whether the types of the provided values match the method signature before trying to pass them. Avoiding ClassCastException<\/span>s <\/p>\n\n\n\n
interface MethodAwareTriConsumer extends TriConsumer, ParamTypeAware {\n   default void tryAccept(T one, U two, V three) {\n       if (acceptsTypes(one, two, three)) {\n           accept(one, two, three);\n       }\n   }\n   default boolean acceptsTypes(Object one, Object two, Object three) {\n       return paramType(0).isAssignableFrom(one.getClass())\n               && paramType(1).isAssignableFrom(two.getClass())\n               && paramType(2).isAssignableFrom(three.getClass());\n   }\n  \n   default Class paramType(int n) {\n       int actualParameters = method().getParameters().length; \/\/ captured final variables may be prepended\n       int expectedParameters = 3;\n       return method().getParameters()[(actualParameters - expectedParameters) + n].getType();\n   }\n}<\/pre>\n\n\n\n
Then put all this together and we can pattern match against Objects of unknown type, and deconstruct them if they're records matching the provided lambda type-pattern.<\/p>\n\n\n\n
record Colour(Integer r, Integer g, Integer b) {}\n\nObject unknown = new Colour(5,6,7); \/\/ note the Object type\n\nint result = withFallback(-1).\n    If.instance(unknown, (Integer r, Integer g, Integer b) ->\n       r + g + b\n    );\n\nassertEquals(18, result);<\/pre>\n\n\n\n
Degrading safely if the pattern does not match<\/p>\n\n\n\n
Object unknown = new Name(\"benji\", \"weber\");\n\nint result = withFallback(-1).\n    If.instance(unknown, (Integer r, Integer g, Integer b) ->\n       r + g + b\n    );\n\nassertEquals(-1, result);<\/pre>\n\n\n\n
Code for the record deconstruction and several more examples all in this test on github<\/a>. Hopefully all this will be made redundant by future enhancements to Java's type patterns :)<\/p>\n","protected":false},"excerpt":{"rendered":"
Java 16 brings Pattern Matching for instanceof. It’s a feature with exciting possibilities, though quite limited in its initial incarnation.  Basic Pattern Matching We can now do things like  Object o = “hello”; if (o instanceof String s) { System.out.println(s.toUpperCase()); } Note the variable “s”, which is then used without any casting needed. Deconstructing Optionals…  Read more »<\/a><\/p>\n","protected":false},"author":2,"featured_media":1695,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[8],"tags":[],"yoast_head":"\n\n\n\n\n\n\n\n\n\n\n\n\n\t\n\t\n\n