Grammars are a powerful tool in Raku for pattern matching and transformation. This post will cover several exercises from https://exercism.org/ which are great for experimenting with this functionality.
This post is a breakdown of my own use of grammars. If you would like to learn more about them, there is an introduction post from @jj which can be found here: https://dev.to/jj/introduction-to-grammars-with-perl6-75e
Phone Number
Check and return a valid phone number with non-digit characters stripped:
https://exercism.org/tracks/raku/exercises/phone-number
This exercise uses the North American Numbering Plan (NANP) as the phone number format, a ten-digit telephone number in the form of NPA-NXX-XXXX, where N represents a digit 2 through 9, and X represents a digit 0 through 9.
Let's start off with checks for N and X.
token X { <[0..9]> }
token N { <+X - [01]> <!before 11> }
token X
is the simplest here, merely being digits 0-9. token N
is X
with 0 and 1 removed, and an additional check has been added to ensure that this digit can't come before two sequential 1s (known as an N11 code e.g. 911).
The second and third portions of the number (NXX and XXXX) are known as exchange and station codes.
token exchange-code { <.N> <.X> ** 2 }
token station-code { <.X> ** 4 }
NPA (AKA the area code) has some additional rules in the real world. This is not relevant for this exercise so let's just copy exchange-code
.
token area-code { <.exchange-code> }
Now that all the needed parts of the number are defined, let's create a rule called TOP
to bring it all together, with an extra part to check for a country code (a 1, with an optional leading plus sign).
rule TOP { ['+'? 1]? <area-code> <exchange-code> <station-code> }
A rule
and a token
differ in how they handle whitespace. See more here: https://docs.raku.org/language/grammars#ws
And finally, let's alter what is considered to be whitespace. I'll be taking the lazy approach by matching anything that isn't 0-9.
token ws { <-X>* }
All together this looks like:
grammar NANP {
rule TOP { ['+'? 1]? <area-code> <exchange-code> <station-code> }
token area-code { <.exchange-code> }
token exchange-code { <.N> <.X> ** 2 }
token station-code { <.X> ** 4 }
token N { <+X - [01]> <!before 11> }
token X { <[0..9]> }
token ws { <-X>* }
}
The important parts needed to complete this exercise will be named in a Match
object. Let's now write a class which will be used to transform a Match
into the desired format.
class Cleaner {
method TOP ($/) {
make [~] $<area-code exchange-code station-code>;
}
}
The TOP
method (which will operate on the TOP
match) will take a Match
object, and concatenate the area-code
, exchange-code
, and station-code
portions of that match into a string. The make
routine will attach any given payload (the string in this case) to the Match
object, which can be retrieved with the made
routine.
The following example will return 9876543210
:
NANP.parse('+1 (987) 654-3210', :actions(Cleaner)).made;
My published solution to this exercise can be found here: https://exercism.org/tracks/raku/exercises/phone-number/solutions/m-dango
ISBN Verifier
Identify whether given data is a valid ISBN-10:
https://exercism.org/tracks/raku/exercises/isbn-verifier
This exercise uses a simpler grammar than the previous. A set of 9 digits, and a 10th digit or X, separated by dashes.
grammar ISBN {
rule TOP { <digit> ** 9 [ <digit> | X ] }
token digit { <[0..9]> }
token ws { '-'? }
}
The class being used for actions however is a bit more involved.
class Validator {
method TOP ($/) {
make ( (|$<digit>, 10) Z* (10...1) ).sum %% 11;
}
}
Here all the matched digits are multiplied using the zip metaoperator, i.e., the 1st digit is multiplied by 10, the 2nd multiplied by 9, etc. If there were 10 digits in the match, the subsequent 10 (which is there to substitute an X
from the Match
) is ignored. The result of this zip is then added up by the sum
routine, and then that result is checked for divisibility by 11. The final payload will be a Bool
for this check.
My published solution to this exercise can be found here: https://exercism.org/tracks/raku/exercises/isbn-verifier/solutions/m-dango
Wordy
Parse and solve a written mathematical problem:
https://exercism.org/tracks/raku/exercises/wordy
I had a lot of fun with this one! A mathematical problem is given in the form of a question in English, and a numeric solution is expected as a result. The operations are expected to be resolved from left to right.
What is 3 plus 2 multiplied by 3?
=
15
First, let's take the expected operations, and associate them with the appropriate functions.
constant %OPS =
'plus' => &infix:<+>,
'minus' => &infix:<->,
'multiplied by' => &infix:<×>,
'divided by' => &infix:<÷>,
;
Then, in the grammar, let's use the keys from this hash inside a token.
token op { @(%OPS.keys) }
Every number in the string will be a positive or negative integer, so let's use something simple to match those.
token number { '-'? <[0..9]>+ }
And now let's pair these up to create a function with them later.
rule func { <op> <number> }
In the corresponding action, let's now create some methods to build functions.
method func ($/) {
make -> $x { $<op>.made.($x, $<number>) };
}
method op ($/) {
make %OPS{$/};
}
If plus 2
were part of the given text, what would happen is the op
method would fetch the &infix:<+>
routine from the %OPS
hash, and the func
method would create a new function: -> $x { &infix:<+>($x, 2) }
, or more simply -> $x { $x + 2 }
.
Let's now put together the final TOP matcher and method.
rule TOP { What is <number> <func>* '?' }
method TOP ($/) {
make $<number>.&( [R∘] $<func>.map(*.made) );
}
$<func>
will be an array which can contain 0 or more matches. The map
will retrieve each function created by the func
method, and these functions are then reduced using the function composition operator, ultimately creating a single function to call with the first number from the match. The function composition operator usually has the left function called with the result of the right function, so the R
metaoperator is used to reverse this.
As an example, the phrase What is 1 plus 2 multiplied by 3?
is transformed into the equivalent of:
1
==> -> $x { $x + 2 }()
==> -> $x { $x * 3 }();
My published solution to this exercise can be found here: https://exercism.org/tracks/raku/exercises/wordy/solutions/m-dango
Meetup
Determine a date from a written description:
https://exercism.org/tracks/raku/exercises/meetup
This grammar is also a straightforward one, intended to match a description such as Second Friday of December 2013
. Month, Weekday and Week are all set up as enums. 1 to 12 for Jan to Dec, 1 to 7 for Mon to Sun, and Week being the first possible day of each week expected from the description.
enum Week (
|(<First Second Third Fourth> Z=> (1, 8 ... *)),
Teenth => 13,
);
grammar Description {
rule TOP { <week> <weekday> of <month> <year> }
token week { @(Week.keys) | Last }
token weekday { @(Weekday.keys) }
token month { @(Month.keys) }
token year { <[0..9]>+ }
}
Last
is a special case so a specific value has not been assigned to it.
The TOP
method in the action class then has a few steps.
First, a date object is created for the wanted week.
my Date $week.=new(
year => $<year>,
month => ::($<month>),
|(day => ::($<week>) if $<week> ne 'Last'),
);
A day is not specified if the last week is wanted. Instead, a condition is used to adjust this date to the beginning of the final week.
if $<week> eq 'Last' {
$week.=later( (months => 1, weeks => -1) );
}
And with the date now being at the start of the given week, let's adjust it to match the wanted day of the week.
make .later(days => (::($<weekday>) - .day-of-week) % Weekday.keys) given $week;
If the start of the week is a Friday (5) and the desired day is a Tuesday (2), the date will be advanced by (2 - 5) % 7 = 4
days.
My published solution to this exercise can be found here: https://exercism.org/tracks/raku/exercises/meetup/solutions/m-dango
I hope you've enjoyed these examples of grammars, and I hope to see and experiment with more applications of them in future!
Top comments (0)