Ruby 2.7 — Pattern Matching — First Impressions
Shall we grab a sneak peak at what Pattern Matching looks like in Ruby 2.7? The code’s merged, nightly build is on the way, and I’m a rather impatient writer who wants to check out the new presents.
This is my first pass over pattern matching, and there will be more detailed articles coming out as I have more time to experiment with the features.
To be clear: This article will meander as it’s a first impression. I’ll be running more tests on it tomorrow, but wanted to write something on it tonight to see how well first impressions matched up.
The Short Version
This is going to be a long article, and the short version isn’t going to cover even a small portion of it. Each major section will have a single style it covers.
The test file covers a good portion of this if you want an at-a-glance read:
Literal Matches
Much like a regular case
statement, you can perform literal matches:
case 0
in 0 then true
else false
end
# => true
In these cases it would probably be best to use when instead.
The difference is that if there’s no match it’s going to raise aNoMatchingPattern
error rather than returning nil
like case
/ when
statements would.
Multiple Matchers
In typical case
statements, a comma would be used, but with some of the new syntax this would break some of the destructuring that will be mentioned later:
case 0
in 0 | 1
true
end
# => true
In the case of captured variables below, they can’t be mixed:
case 0
in a | 0
end
# Error: illegal variable in alternative pattern
Captured Variables
One of the more interesting additions is captured variables:
case true
in a
a
end
# => true
In Guard Clauses
These can also be used in suffix conditionals or rather guard type clauses in what’s reminiscent of Haskell:
case 0
in a if a == 0
true
end
# => true
In Assignment Mappings
They can even be assigned with a Hash-like syntax:
case 0
in 0 => a
a == 0
end
With Placeholders
Most interesting in this section is that they appear to treat underscores as a special placeholder:
case 0
in _ | _a
true
end
Though this could also be seen as a literal variable assignment, it’s an interesting riff on Scala’s pattern matching wildcards.
Destructuring
Interestingly you can shadow the variables as well while destructuring an array:
case [0, 1]
in a, a
a == 1
end
# => true
It appears that the last assignment will be a in this case, and that commas are now used for destructuring rather than for denoting a separate pattern to match against as is the case for when.
Deconstruct
In the top of the file there’s a class defined:
class C
class << self
attr_accessor :keys
end
def initialize(obj)
@obj = obj
end
def deconstruct
@obj
end
def deconstruct_keys(keys)
C.keys = keys
@obj
end
end
It appears to indicate a way to define how an object should be destructured by pattern matching:
[[0, 1], C.new([0, 1])].all? do |i|
case i
in 0, 1
true
end
end
including accounting for unbalanced matches:
[[0], C.new([0])].all? do |i|
case i
in 0, 1
else
true
end
end
I don’t understand how deconstruct_keys
is working, but it feels really odd to me from first glance.
With Splats
It also will capture multiple arguments like destructuring currently works on Ruby arrays:
case []
in *a
a == []
end
case [0, 1, 2]
in *a, 1, 2
a == [0]
end
Meaning that *
could also be used as a bit of a wildcard:
case 0
in *
true
end
On Hashes
These appear to work a lot like keyword arguments:
case {a: 0}
in a: 0
true
end
That also means that kwsplats could be used here:
case {}
in **a
a == {}
end
…and with the keywords bit above, that means that classes could define their own destructuring using keywords, but I’m not clear on that.
I’m really hoping that this also uses ===
on each param, but the tests don’t indicate this. I’ll be experimenting with this later.
Triple Equals
Like our current case statements, it appears that the new method of pattern matching uses===
for comparisons:
case 'abc'
in /a/
true
end
case 0
in -> i { i == 0 }
true
end
Combined with Destructuring
One thing I enjoyed in Qo
was the ability to match against another array using ===
to write queries. It looks like the new syntax will compare each element and give us something very similar:
case [0, 1, 2, 3, 4, 5]
in [0..1, 0...2, 0.., 0..., (...5), (..5)]
true
end
It’s amusing that they’ve included beginningless and endless ranges in the example, as that could be very useful later on. I certainly hope these work with hashes, as I really really really want this to work:
case object
in method_a: 0..10, method_b: String
true
end
…because if we can define our own deconstructors just imagine the possibilities there. The class attr for keys is odd though, not sure what to think of that one.
Pin Operator
I’m going to have to come back to this one as I do not understand it. I assume it means not to assign and to “pin” a variable so it doesn’t get overwritten:
a = /a/
case 'abc'
in ^a
true
end
case [0, 0]
in a, ^a
a == 0
end
I believe this can be used to capture one element in a variable and also reference it later like a back-reference of sorts.
Thoughts?
This hasn’t built with Nightly yet, so I intend to make a second pass on this after it clears to verify some behavior I have suspicions about. Mostly I want to see about the hash matchers, as there’s some amazing potential there.
Going to be digging through and playing with this over the next few weeks, here’s the next post in the series:
Top comments (0)