The simplest way to perform ciphering would be to use a dictionary. We can make a dictionary that maps characters to other characters like so:
rot13: "abcdefghijklmnopqrstuvwxyz" dict "nopqrstuvwxyzabcdefghijklm"
Given a string, we can use each character to index into our dictionary with the "@" operator:
rot13 @ "something else"
# ("f","b","z","r","g","u","v","a","t",nil,"r","y","f","r")
For characters like spaces, which aren't defined in the rot13 dictionary, we get a nil. As a catchall, we can use "fill" to substitute a generic replacement for all nils:
" " fill rot13 @ "something else"
# ("f","b","z","r","g","u","v","a","t"," ","r","y","f","r")
And if we wanted to collapse that sequence of characters into a flat string, we can use "fuse". Note that this step isn't necessary if we're stashing the result in a field's .text attribute; it implicitly fuses lists of strings as a convenience:
"" fuse " " fill rot13 @ "something else" # "fbzrguvat ryfr"
Putting that all together, given fields "input" and "output", give "input" a change[] handler:
on change do rot13: "abcdefghijklmnopqrstuvwxyz" dict "nopqrstuvwxyzabcdefghijklm" output.text:" " fill rot13 @ input.text end
And now we have a (crude) rot13 translator. It would probably be much more useful if we preserved all the non-alphabetic characters intact instead of turning them all into spaces. We can be a little fancier about how we construct the translation dictionary and address this:
on change do a1:"abcdefghijklmnopqrstuvwxyz" a2:"nopqrstuvwxyzabcdefghijklm" A1:"%u" format a1 A2:"%u" format a2 chars:"%a" format list range 256 rot13:(chars dict chars),(a1 dict a2),(A1 dict A2) output.text:rot13 @ input.text end
If you want to do a translation based on fixed-size bigrams or trigrams, or something along those lines, "window" might be useful:
2 window "SomeWords!"
#("So","me","Wo","rd","s!")
And you can use "drop" to exclude characters you wish to ignore (or conversely, "take" to retain only characters you care about):
(" ","!") drop "Some Words!"
# ("S","o","m","e","W","o","r","d","s")
For even fancier find-and-replace scenarios you could use RText.replace[]. Note that this returns a rich-text table and should be assigned to the .value attribute of a field, rather than .text, or converted into a string with rtext.string[].
rtext.replace["some text" ("me","ex") ("you","post")]
# +----------------+------+-----+-----+
# | text | font | arg | pat |
# +----------------+------+-----+-----+
# | "soyou tpostt" | "" | "" | 1 |
# +----------------+------+-----+-----+
rtext.string[rtext.replace["some text" ("me","ex") ("you","post")]]
# "soyou tpostt"
Does any of that help?