Pattern Matching: Small Enhancement or Major Feature? (talk from jLove 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/DefiantElasticGadwall.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

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 ('flow scoping')
The set of places where it would definitely be
assigned.
// 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;
}
// 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

Benefits
Benefits
Nearly 100% of casts will just disappear!
More concise
No type repeating

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

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

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

Sensible operations to the
Sensible operations to the
effect loop
effect loop
apply()
setVolume(int volume)
contains(Effect... effect)

Nonsensical operations to the
Nonsensical operations to the
effect loop
effect loop
isTunerActive()
isDelayTimeEqualToReverbRoomSize()
isToneSuitableToPlayPrideInTheNameOfLov

Visitor pattern
Visitor pattern
interface EffectVisitor<T> {

T visit(Tuner effect);

T visit(Delay effect);

T visit(Reverb effect);

// ...
}

class IsTunerActiveVisitor implements EffectVisitor<Boolean> {

public Boolean visit(Tuner effect) {

return !effect.isInTune();

}
public Boolean visit(Delay effect) { return false; }

public Boolean visit(Reverb effect) { return false; }

// ...
}

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

Benefits
Benefits
No need for the Visitor pattern or a common
supertype
A single expression instead of many assignments
Less error-prone (in adding cases)
More concise
Safer - the compiler can check for missing cases

What happens if
What happens if effect
effect is
is
null
null?
?
};
}
1
2
3
4
5
6
7
8
9
10
11

What happens if
What happens if effect
effect is
is
null
null?
?
return switch(effect) { // throws NullPointerException!
1
2
3
4
5
6
7
8
9
};
10
}
11

Solution #1: defensive testing
Solution #1: defensive testing
if (effect == null) {
return "Malfunctioning effect active.";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
};
14
}
15

Solution #2: integrate null
Solution #2: integrate null
check in switch
check in switch
case null -> return "Malfunctioning effect active.";
1
2
3
4
5
6
7
8
9
10
};
11
}
12

Combining case labels
Combining case labels
case null, default -> String.format("Unknown or malfunctionin
1
2
3
4
5
6
7
8
9
};
10
}
11

Guarded patterns
Guarded patterns
String apply(Effect effect, Guitar guitar) {
// (...)
case Tremolo tr-> String.format("Tremolo active with depth %d
case Tuner tu -> String.format("Tuner active with pitch %d. Mu
default -> String.format("Unknown effect active: %s.", effect)
};
}
1
2
3
4
5
6
7
8
9
https://openjdk.java.net/jeps/406

Guarded patterns
Guarded patterns
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

Guarded patterns
Guarded patterns
switch(effect) {
// ...
case Tuner tu:
if (!tu.isInTune(guitar)) { // tuning is needed }
else { // no tuning is needed }
break;
// ...
}
1
2
3
4
5
6
7
8

Guarded patterns
Guarded patterns
switch(effect) {
// ...
case Tuner tu && !tu.isInTune(guitar) -> // tuning is needed
case Tuner tu -> // no tuning is needed
// ...
}
1
2
3
4
5
6

Feature Status
Feature Status
17 Preview JEP 406

Deconstruction
Deconstruction
Deconstruction
Deconstruction
Deconstruction
Patterns
Patterns
Patterns
Patterns
Patterns

Disclaimer
Disclaimer
Disclaimer
Disclaimer
Disclaimer
I can't tell you when the following
features are coming to Java.

Also: syntax and implementation
specifics may still change.

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 definition
Pattern definition
public class Overdrive implements Effect {
private final int gain;
public Overdrive(int gain) {
this.gain = gain;
}
}
1
2
3
4
5
6
7

Pattern definition
Pattern definition
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(E
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 isDelayTimeEqualToReverbRoomSize(EffectLoop effectLoop)
}
1
2
3

Pattern composition
Pattern composition
static boolean isDelayTimeEqualToReverbRoomSize(EffectLoop effectLoop
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

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

Optimization
Optimization
case EffectLoop(var effects) -> effects.stream().map(Effect::
};
}
1
2
3
4
5
6
7
8
9
10
11

Optimization
Optimization
case EffectLoop(var effects) -> effects.stream().map(Effect::ap
1
2
// ...
3
4
5
};
6
}
7

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

Benefits
Benefits
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

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

Completeness on pattern switch
expressions
expressions
static String apply(Object object) {
return switch(object) {
case Effect e -> e.apply();
case String s -> String.format("Tried to apply a String: %s",
case Number n -> String.format("Tried to apply a Number: %d",
};
}
1
2
3
4
5
6
7

expressions
expressions
return switch(object) { // Won't compile - incomplete!
1
2
3
4
5
};
6
}
7

expressions
expressions
default -> String.format("Tried to apply an Object: %s",
1
return switch(object) {
2
3
4
5
6
};
7
}
8

Demo
Demo
Make Effect a sealed type

Sealed types yield
Sealed types yield
completeness
completeness
};
}
1
2
3
4
5
6
7
8
9
10
11
12

Sealed types yield
Sealed types yield
completeness
completeness
};
}
1
2
3
4
5
6
7
8
9
10
11

Demo
Demo
Convert an implementing class to a record
Acquire constructor, accessor methods etc.

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

Record patterns
Record patterns
record Amplifier(String name, EffectLoop stockEffects, EffectLoop auxE
record EffectLoop(Delay delay, Reverb reverb) { }
1
2
static String switchOn(Amplifier amplifier) {
return switch(effectLoop) {
// ...
case Amplifier(var name, EffectLoop(Delay(int timeInMs), Reverb
// ...
}
}
1
2
3
4
5
6
7

Array patterns
Array patterns
record EffectLoop(String name, int volume, Effect... effects) { }
1
static String apply(EffectLoop effectLoop) {}
return switch(effectLoop) {
case EffectLoop(var name, var volume) -> " Effect loop contain
case EffectLoop(var name, var volume, var effect) -> "Effect lo
case EffectLoop(var name, var volume, var effect, ...) -> "Eff
case EffectLoop(var name, var volume, var effect1, var effect2
case EffectLoop(var name, var volume, var effect1, var effect2
}
}
1
2
3
4
5
6
7
8
9

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

Feature Status
Feature Status
Completeness
Completeness
17 Preview JEP 406

Feature Status
Feature Status
Record & Array Patterns
Record & Array Patterns
18 Preview JEP 405

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

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/

Opposites
Opposites
Deconstruction pattern
Deconstruction pattern
transforms an object into a set of typed fields
Constructor
Constructor
transforms a set of typed fields 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

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

Other ideas
Other ideas
Deconstruction patterns for all classes
Enhanced array patterns

String[] { [8] -> var eighthElement, [9] -> var ninthElement}
AND patterns
Patterns in catch clauses
Collection patterns
https://mail.openjdk.java.net/pipermail/amber-spec-experts/2021-January/002758.html

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

#jLoveConf #PatternMatching @hannotify
Thank you! ☺️
Thank you! ☺️
bit.do/jlove-pattern-matching
github.com/hannotify/pattern-
matching-music-store
hanno.codes
@hannotify

Pattern Matching: Small Enhancement or Major Feature? (talk from jLove 2021)

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Pattern Matching: Small Enhancement or Major Feature? (talk from jLove 2021)

Ähnlich wie Pattern Matching: Small Enhancement or Major Feature? (talk from jLove 2021) (20)

Mehr von 🎤 Hanno Embregts 🎸

Mehr von 🎤 Hanno Embregts 🎸 (16)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Pattern Matching: Small Enhancement or Major Feature? (talk from jLove 2021)