In the last post, I introduced a very simple find-and-replace in parse.
Let’s refactor this a bit to set some rules and in doing so, make this code more readable.
So we had this:
s: "this is a fantastic day" parse s [to "fantastic" change "fantastic" "great"]
which replaces one instance of “fantastic” with “great”.
We could break down the rules above into:
key-word: "fantastic" my-find: [to key-word] my-replace: [change key-word "great"] parse s [my-find my-replace]
This will help make the parse part a little more readable or understandable.
When run in the REPL, this will result in s being updated to:
s == "this is a great day"
The readability comes about by creating rules for my-find and for my-replace. Each rule is placed in square brackets or a block. Without the brackets, you’d get an error.
Because parse evaluates rules from left to right, the first rule my-find is evaluated first, and if successfully evaluated, then parse moves onto my-replace.
It’s possible to make the code perhaps a little more elegant by:
do-this-action: [my-find my-replace]
and then parse becomes:
parse s do-this-action
You get the idea.
This concept of setting up granular rules will greatly help maintain clarity and maintainability as you write your own parsing routines.