Pattern Matching: From Small Enhancement to Major Feature (talk from JavaLand 2021)

Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Pattern
Matching
Matching
Matching
Matching
Matching
Matching
Matching
Matching
Matching
Matching
Matching
Matching
From Small Enhancement to Major Feature
From Small Enhancement to Major Feature
Hanno Embregts @hannotify

Small Enhancement
Small Enhancement
Small Enhancement
Small Enhancement
Small Enhancement
https://gph.is/g/ZPJNoPQ

Major Feature
Major Feature
Major Feature
Major Feature
Major Feature
https://thumbs.gfycat.com/De antElasticGadwall.webp

Pattern
Pattern
Pattern
Pattern
Pattern
Matching for
Matching for
Matching for
Matching for
Matching for
instanceof
instanceof
instanceof
instanceof
instanceof
https://pxhere.com/en/photo/752901

Instanceof-and-cast
Instanceof-and-cast
if (product instanceof Guitar) {
Guitar lesPaul =
(Guitar) product;
// use lesPaul
}
1
2
3
4
5

Instanceof-and-cast
Instanceof-and-cast
if (product instanceof Guitar) { // 1. is product a Guitar?
1
Guitar lesPaul =
2
(Guitar) product;
3
// use lesPaul
4
}
5

Instanceof-and-cast
Instanceof-and-cast
(Guitar) product; // 2. perform conversion
1
Guitar lesPaul =
2
3
// use lesPaul
4
}
5

Instanceof-and-cast
Instanceof-and-cast
Guitar lesPaul = // 3. declare variable, bind value
1
2
3
// use lesPaul
4
}
5

Improve the situation
Guitar lesPaul = // 3. declare variable, bind value
// use lesPaul
}
1
2
3
4
5

if (product instanceof Guitar lesPaul) {
// use lesPaul
}
1
2
3

Type pattern
Type pattern
Type pattern
Type pattern
Type pattern
Consists of a predicate that speci es
a type, along with a single binding
variable.
https://www.pexels.com/photo/person-holding-white-chalk-625219/

Pattern matching
Pattern matching
Pattern matching
Pattern matching
Pattern matching
Allows the conditional extraction of
components from objects to be
expressed more concisely and safely.
https://www.pexels.com/photo/person-holding-white-chalk-625219/

Declaring 'in the
Declaring 'in the
middle'
middle'
// use lesPaul
}
1
2
3

Scoping
Scoping
'Regular' local variable ('block scoping')
The block in which it is declared.
void playTunedGuitar() {
Guitar lesPaul = new Guitar("Les Paul");
if (!lesPaul.isInTune()) {
Guitar fenderStrat = new Guitar("Fender Stratocaster");
fenderStrat.play();
}
}
1
2
3
4
5
6
7
8

Scoping
Scoping
The block in which it is declared.
void playTunedGuitar() {
Guitar lesPaul = new Guitar("Les Paul");
if (!lesPaul.isInTune()) {
Guitar fenderStrat = new Guitar("Fender Stratocaster");
fenderStrat.play();
// fenderStrat is in scope
}
// fenderStrat is not in scope
}
1
2
3
4
5
6
7
8
9
10

Scoping
Scoping
Pattern binding variable (' ow scoping')
The set of places where it would de nitely be
assigned.
// can use lesPaul here
} else {
// can't use lesPaul here
}
1
2
3
4
5

Scoping
Scoping
assigned.
if (product instanceof Guitar lesPaul && lesPaul.isInTune()) {
// can use lesPaul here
} else {
// can't use lesPaul here
}
1
2
3
4
5

Scoping
Scoping
assigned.
boolean isTunedGuitar(Object product) {
if (!(product instanceof Guitar lesPaul)) {
return false;
}
return lesPaul.isInTune();
}
1
2
3
4
5
6
7

Scoping
Scoping
assigned.
boolean isTunedGuitar(Object product) {
if (!(product instanceof Guitar lesPaul)) {
return false;
}
// This code is only reachable if 'product' is
// a Guitar, so 'lesPaul' is in scope.
return lesPaul.isInTune();
}
1
2
3
4
5
6
7
8
9

Scoping
Scoping
assigned.
void test(Effect effect) {
if (effect instanceof Reverb stockEffect)
stockEffect.setRoomSize(25);
else if (effect instanceof Delay stockEffect)
stockEffect.setTimeInMs(200);
}
1
2
3
4
5
6

Demo
Demo
Simplify implementation of equals
Loop through a set of Effects and apply 'pattern
matching for instanceof'

Bene ts
Bene ts
Nearly 100% of casts will just disappear!
More concise
Eliminates cut/paste errors

instanceof
instanceof grammar
grammar
The
The instanceof
instanceof grammar is extended accordingly:
grammar is extended accordingly:
RelationalExpression instanceof Pattern
Pattern:
ReferenceType Identifier
RelationalExpression:
1
...
2
RelationalExpression instanceof ReferenceType
3
4
5
6
7
https://openjdk.java.net/jeps/305

It's a kind of Pattern
type pattern
Guitar lesPaul
https://www.pexels.com/photo/gray-metal-statue-of-man-raising-hand-near-dock-825430/

Feature Status
Feature Status
Java version Feature status JEP
14 Preview
15 Second preview
16 Final
JEP 305
JEP 375
JEP 394

Why so serious?
Why so serious?
Surely a less invasive approach exists?
Flow typing has been considered.
It infers re ned types based on past conditionals.
But... it is suited for instanceof checks only.
And pattern matching can be useful for more
language concepts!

Pattern
Pattern
Pattern
Pattern
Pattern
Matching for
Matching for
Matching for
Matching for
Matching for
switch
switch
switch
switch
switch

Disclaimer
Disclaimer
Disclaimer
Disclaimer
Disclaimer
I can't tell you when the following
features are coming to Java.
Also: syntax and implementation
speci cs may still change.

String apply(Effect effect) {
String formatted = "";
if (effect instanceof Delay) {
Delay de = (Delay) effect;
formatted = String.format("Delay active of %d ms.", de.getTim
} else if (effect instanceof Reverb) {
Reverb re = (Reverb) effect;
formatted = String.format("Reverb active of type %s and roomS
} else if (effect instanceof Overdrive) {
Overdrive ov = (Overdrive) effect;
formatted = String.format("Overdrive active with gain %d.", ov
} else if (effect instanceof Tremolo) {
Tremolo tr = (Tremolo) effect;
formatted = String.format("Tremolo active with depth %d and r
} else if (effect instanceof Tuner) {
Tuner tu = (Tuner) effect;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1
2
if (effect instanceof Delay) {
3
Delay de = (Delay) effect;
4
5
} else if (effect instanceof Reverb) {
6
Reverb re = (Reverb) effect;
7
8
} else if (effect instanceof Overdrive) {
9
Overdrive ov = (Overdrive) effect;
10
11
} else if (effect instanceof Tremolo) {
12
Tremolo tr = (Tremolo) effect;
13
14
} else if (effect instanceof Tuner) {
15
Tuner tu = (Tuner) effect;
16

if (effect instanceof Delay de) {
} else if (effect instanceof Reverb re) {
} else if (effect instanceof Overdrive ov) {
} else if (effect instanceof Tremolo tr) {
} else if (effect instanceof Tuner tu) {
formatted = String.format("Tuner active with pitch %d. Muting
} else if (effect instanceof EffectLoop el) {
formatted = el.getEffects().stream().map(this::apply).collect
} else {
formatted = String format("Unknown effect active: %s " effect
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

formatted = String.format("Tuner active with pitch %d. Muting
formatted = el.getEffects().stream().map(this::apply).collect
formatted = String format("Unknown effect active: %s " effect
1
2
if (effect instanceof Delay de) {
3
4
} else if (effect instanceof Reverb re) {
5
6
} else if (effect instanceof Overdrive ov) {
7
8
} else if (effect instanceof Tremolo tr) {
9
10
} else if (effect instanceof Tuner tu) {
11
12
} else if (effect instanceof EffectLoop el) {
13
14
} else {
15
16

Switch expression
Switch expression
return switch(effect) {
default -> String.format("Unknown effect active: %s
};
}
1
2
3
4
5

Switch expression
Switch expression
case Delay de -> String.format("Delay active of %d ms.",
case Reverb re -> String.format("Reverb active of type %s
1
2
3
4
default -> String.format("Unknown effect active: %s
5
};
6
}
7

Switch expression
Switch expression
case Overdrive ov -> String.format("Overdrive active with ga
case Tremolo tr -> String.format("Tremolo active with depth
case Tuner tu -> String.format("Tuner active with pitch
1
2
3
4
5
6
7
default -> String.format("Unknown effect active: %
8
};
9
}
10

Switch expression
Switch expression
case EffectLoop el -> el.getEffects().stream().map(this::apply
1
2
3
4
5
6
7
8
9
};
10
}
11

Switch expression
Switch expression
};
}
1
2
3
4
5
6
7
8
9
10
11

Bene ts
Bene ts
A single expression instead of many assignments
Less error-prone (in adding cases)
More concise
Safer - the compiler can check for missing cases

switch
switch grammar
grammar
SwitchBlock:
{ SwitchRule {SwitchRule} }
{ {SwitchBlockStatementGroup} {SwitchLabel :} }
SwitchRule:
SwitchLabel -> Expression ;
SwitchLabel -> Block
SwitchLabel -> ThrowStatement
SwitchBlockStatementGroup:
SwitchLabel : {SwitchLabel :} BlockStatements
SwitchLabel:
case CaseConstant {, CaseConstant}
default
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.11

switch
switch grammar
grammar
case CaseConstant {, CaseConstant}
SwitchBlock:
1
2
3
4
SwitchRule:
5
6
7
8
9
10
11
12
SwitchLabel:
13
14
default
15
16
https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.11

switch
switch grammar
grammar
case Pattern {, Pattern}
SwitchBlock:
1
2
3
4
SwitchRule:
5
6
7
8
9
10
11
12
SwitchLabel:
13
14
default
15
16

constant pattern
GuitarType.TELECASTER

Feature Status
Feature Status
Java
version
Feature
status
JEP
n/a Draft JEP draft
8213076

Why so serious?
Why so serious?
Surely a less invasive approach exists?
Type switching has been considered.
It enables case labels to specify types, as well as
constants.
But... it is suited for switch statements only.
And pattern matching can be useful for more
language concepts!

Deconstruction
Deconstruction
Deconstruction
Deconstruction
Deconstruction
Patterns
Patterns
Patterns
Patterns
Patterns

Here be dragons!
Here be dragons!
Here be dragons!
Here be dragons!
Here be dragons!
We can't be sure at all that the
following features will appear in Java
as depicted. They can change a lot in
the meantime.
https://www.pexels.com/photo/dragon-festival-during-nighttime-6068535/

Deconstruction patterns
};
}
1
2
3
4
5
6
7
8
9
10
11

case Overdrive(int gain) -> String.format("Overdrive active w
1
2
3
4
5
6
7
8
9
};
10
}
11

Pattern de nition
Pattern de nition
public class Overdrive implements Effect {
private final int gain;
public Overdrive(int gain) {
this.gain = gain;
}
}
1
2
3
4
5
6
7

Pattern de nition
Pattern de nition
public pattern Overdrive(int gain) {
gain = this.gain;
}
public class Overdrive implements Effect {
1
private final int gain;
2
3
public Overdrive(int gain) {
4
this.gain = gain;
5
}
6
7
8
9
10
}
11

case Delay(int timeInMs) -> String.format("Delay active of %d
case Reverb(String name, int roomSize) -> String.format("Reve
case Tremolo(int depth, int rate) -> String.format("Tremolo ac
case Tuner(int pitchInHz) -> String.format("Tuner active with
case EffectLoop(Set<Effect> effects) -> effects.stream().map(t
default -> String.format("Unknown effect active: %s.", effect
};
}
1
2
3
4
5
6
7
8
9
10
11

Pattern composition
Pattern composition
static boolean containsReverbAndDelayWithEqualProperties(EffectLoop ef
}
1
2
3

Pattern composition
Pattern composition
static boolean containsReverbAndDelayWithEqualProperties(EffectLoop e
return effectLoop.getEffects().stream()
.filter(e -> e instanceof Delay || e instanceof Reverb)
.map(dr -> {
if (dr instanceof Delay d) {
return d.getTimeInMs();
} else {
Reverb r = (Reverb) dr;
return r.getRoomSize();
}
}).distinct().count() == 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Pattern composition
Pattern composition
if (effectLoop instanceof EffectLoop(Delay(int timeInMs), Reverb(St
return timeInMs == roomSize;
}
return false;
}
1
2
3
4
5
6

Var and any patterns
// Pre-Java 10
Guitar telecaster = new Guitar("Fender Telecaster Baritone Blacktop", G
// Java 10
var telecaster = new Guitar("Fender Telecaster Baritone Blacktop", Gui
1
2
3
4
5

if (effectLoop instanceof EffectLoop(Delay(int timeInMs), Reverb(St
}
return false;
}
1
2
3
4
5
6

if (effectLoop instanceof EffectLoop(Delay(var timeInMs), Reverb(v
1
2
3
}
4
return false;
5
}
6

http://gph.is/2lFlHIK

if (effectLoop instanceof EffectLoop(Delay(var timeInMs), Reverb(_
}
return false;
}
1
2
3
4
5
6

Optimization
Optimization
};
}
1
2
3
4
5
6
7
8
9
10
11

Optimization
Optimization
1
2
// ...
3
4
default -> String.format("Unknown effect active: %s.", effect)
5
};
6
}
7

Optimization
Optimization
case EffectLoop(Tuner(int pitchInHz), _) -> String.format("The
1
2
// ...
3
4
5
6
};
7
}
8

Bene ts
Bene ts
Better encapsulation
a case branch only receives data that it actually references.
More elegant logic
by using pattern composition
Optimization
through the use of any patterns

deconstruction pattern
Delay(int timeInMs)

var pattern
var timeInMs

any pattern
_

Feature Status
Feature Status
Java
version
Feature status JEP
n/a Exploratory
document
Pattern Matching
for Java
https://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html

Pattern Matching Plays
Pattern Matching Plays
Nice With
Nice With
Sealed Types
Sealed Types
Sealed Types
Sealed Types
Sealed Types
and Records
and Records
and Records
and Records
and Records

Demo
Demo
Convert e ect classes to a record
Acquire constructor, accessor methods etc.

Records
Records
Input:
Input:
Commit to the class being a transparent carrier for
its data.

Records
Records
Input:
Input:
Commit to the class being a transparent carrier for
its data.
Output:
Output:
constructors
accessor methods
equals()-implementation
hashCode()-implementation
toString()-implementation
deconstruction pattern

Demo
Demo
Make Effect a sealed type
Make subclasses final, sealed or non sealed

Exhaustiveness
Exhaustiveness
};
}
1
2
3
4
5
6
7
8
9
10
11
12

Exhaustiveness
Exhaustiveness
};
}
1
2
3
4
5
6
7
8
9
10
11

Feature Status
Feature Status
Records
Records
14 Preview
15 Second preview
16 Final
JEP 359
JEP 384
JEP 395

Feature Status
Feature Status
Sealed Types
Sealed Types
15 Preview
16 Second preview
17 Final ...
JEP 360
JEP 397

A Better
A Better
A Better
A Better
A Better
Serialization
Serialization
Serialization
Serialization
Serialization
?
?
?
?
?

Opposites
Opposites
Deconstruction pattern
Deconstruction pattern
transforms an object into a set of typed elds
Constructor
Constructor
transforms a set of typed elds into an object

Serialization
Serialization
very important feature
but many people hate its current implementation
Drawbacks
Drawbacks
it undermines the accessibility model
serialization logic is not 'readable code'
it bypasses constructors and data validation

Serialization
Serialization
public class EffectLoop implements Effect {
private String name;
private Set<Effect> effects;
public EffectLoop(String name) {
this.name = name;
this.effects = new HashSet<>();
}
}
1
2
3
4
5
6
7
8
9

Serialization
Serialization
public pattern EffectLoop(String name, Effect[] effects) {
name = this.name;
effects = this.effects.toArray();
}
1
2
3
4
5
this.name = name;
6
7
}
8
9
10
11
12
13
}
14

Serialization
Serialization
public static Effectloop deserialize(String name, Effect[] effect
EffectLoop effectLoop = new EffectLoop(name);
for (Effect effect : effects) {
this.effects.add(effect);
}
return effectLoop;
1
2
3
4
5
this.name = name;
6
7
}
8
9
10
11
12
13
14
15
}
16

Serialization
Serialization
this.name = name;
}
@Deserializer
public static Effectloop deserialize(String name, Effect[] effect
EffectLoop effectLoop = new EffectLoop(name);
for (Effect effect : effects) {
this.effects.add(effect);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Some challenges remain
Some challenges remain
Q:
Q: How to support multiple versions of one class?
How to support multiple versions of one class?
A: @Serializer and @Deserializer annotations
could get a property version in the future.

Feature Status
Feature Status
Java
version
Feature status JEP
n/a Exploratory
document
Towards Better
Serialization
https://cr.openjdk.java.net/~briangoetz/amber/serialization.html

Future
Future
Future
Future
Future
Expansions
Expansions
Expansions
Expansions
Expansions

Here be super dragons!
We can't be sure that the following
features will appear in Java as
depicted, if at all.
Proceed with caution!
https://www.pexels.com/photo/dragon-festival-during-nighttime-6068535/

Pattern bind statements
var reverb = new Reverb("ChamberReverb", 2);
__let Reverb(String name, int roomSize) = reverb;
// do something with name & roomSize
1
2
3
4
5

else throw new IllegalArgumentException("not a Reverb!");
var reverb = new Reverb("ChamberReverb", 2);
1
2
__let Reverb(String name, int roomSize) = reverb;
3
4
5
// do something with name & roomSize
6

Guards
Guards
String apply(Effect effect, Guitar guitar) {
1
2
// (...)
3
case Tremolo tr-> String.format("Tremolo active with depth %d
4
case Tuner tu -> String.format("Tuner active with pitch %d. Mut
5
6
7
};
8
}
9

Guards
Guards
case Tuner tu && !tu.isInTune(guitar) -> String.format("Guitar
String apply(Effect effect, Guitar guitar) {
1
2
// (...)
3
case Tremolo tr-> String.format("Tremolo active with depth %d
4
5
6
7
};
8
}
9

Other ideas
Other ideas
Array patterns
Varargs patterns
AND patterns
Patterns in catch clauses
Collection patterns
Record patterns
https://mail.openjdk.java.net/pipermail/amber-spec-experts/2021-January/002758.html

Pattern
Pattern
Pattern
Pattern
Pattern
Kinds and
Kinds and
Kinds and
Kinds and
Kinds and
Contexts
Contexts
Contexts
Contexts
Contexts

Pattern Kinds
Pattern Kinds
Pattern kind Example Purpose
type pattern Guitar lesPaul Perform an instanceof test,
cast the target, and bind it
to a pattern variable.
constant
pattern
GuitarType.TELECASTER Test the target for equality
with a constant.
deconstruction
pattern
Delay(int timeInMs) Perform an instanceof test,
cast the target, destructure
the target and recursively
match the components to
subpatterns.
var pattern var timeInMs Match anything and bind its
target.
any pattern _ Match anything, but bind
nothing.

Pattern Contexts
Pattern Contexts
Pattern
context
Example Purpose
instanceof
predicate
product instanceof
Guitar guitar
Test if target matches the
indicated pattern.
switch
statement or
expression
switch (effect) {
case Delay d
}
Test if target matches one
(or more) of the indicated
patterns.
bind
statement
let Reverb(var
name, var roomSize) =
reverb;
Destructure a target using a
pattern.

Wrap-up
Wrap-up
Wrap-up
Wrap-up
Wrap-up

Pattern matching...
Pattern matching...
is a rich feature arc that will play out over several
versions.
allows us to use type patterns in instanceof.
improves switch expressions.
makes destructuring objects as easy (and more
similar to) constructing them.
holds the potential to simplify and streamline much
of the code we write today.

Major Feature
Major Feature
Major Feature
Major Feature
Major Feature

Thank you! ☺
Thank you! ☺
bit.do/javaland-pattern-
matching
github.com/hannotify/pattern-
matching-music-store
hannotify.github.io
@hannotify

Pattern Matching: From Small Enhancement to Major Feature (talk from JavaLand 2021)

More Related Content

What's hot (10)

Similar to Pattern Matching: From Small Enhancement to Major Feature (talk from JavaLand 2021) (20)

More from 🎤 Hanno Embregts 🎸 (16)

Recently uploaded (20)

Pattern Matching: From Small Enhancement to Major Feature (talk from JavaLand 2021)