Yesterday, I wrote a Thue implementation in Haskell. At this point, the implementation is painfully slow (about 35 minutes to run the brainfuck “Hello World!” through the BF Thue interpreter on my MacBook, as compared to about 4 minutes for the python Thue implementation run in python 2.5.1). I’m thinking I should a) should use ByteString’s instead of String, and b) use some smarter algorithm for matching the rules (instead of untilDone (foldl applyRule input rules), it’d be something more like compiling an automaton out of all rules and untilDone (run automaton)). By reducing the number of rules (eliminating the 50 or so #::=# rules, which are comments in idiomatic Thue but don’t strictly need special processing), I could squeeze about twice the performance out of it – this optimization brought the execution time down to 35 minutes. I need at least 10x the performance before this program is anything to brag about!

Another idea for the future is to implement parallel Thue by splitting up the state and then replacing in the parts until no replacements can be done in parallel, then running a few iterations serially on the whole state. You could also just synchronize once and move the split-point – which would eliminate the problem of deciding when to start going parallell again since you’d never really go serial. With the language designed to allow random replacement order, any valid Thue program already contains the synchronization needed to make it evaluate the right thing and e.g. output things in the correct order, so this is perfectly safe provided you have a correct implementation and correct programs.

Although it’s fun to make things go fast, I think parallel Thue would be much more interesting as it might even be something that’s never been done before!

Anyway, if you want to try it out, here’s my Thue darcs repository, containing the haskell source and the BF interpreter in Thue with the BF Hello world program I’ve been using for testing. It should take exactly 287197 steps (and heaps of time) to complete the execution and print "Hello world!\n" as a series of binary numbers separated by underscores.

Based on the mod_rewrite experiment from the other week, I hacked up a small Thue to mod_rewrite compiler in sed. For testing, I have used the brainfuck interpreter in Thue (as far as I can see, this is like the only example of a “real-world” Thue program). I tested this on the small 3+5 examples included in the BF Thue distribution and tried to test it on BF Hello World, but apache runs out of memory before completing the rewriting

Anyway, in this BF interpreter, the interpretation is bootstrapped by a circumflex, ‘^’, so the interpreter placeholder I introduced last week had a natural use allowing us to simply enter the brainfuck program as a URL, followed by a colon and input as binary underscore-separated numbers (terminated by 0_), and have patience.

The Thue interpreter needs to keep track of a few bits of state – all of this has to be encoded in some reliable way in the URL we’re continually rewriting:

• Have we added the interpreter? For BF+Thue, this is ‘^’ which is really something that has leaked from this one specific Thue program into the interpreter – which is really ugly, but hey, at least it was easy. Anyway, since we’re in the root of the virtual host, we can use the leading slash to encode this information – simply remove it after adding the interpreter, and we can match on ^/(.*)$ to determine whether we should add the bootstrap. (I have since realized that there is not much that prevents a malicious Thue program to output a slash as its first character, thereby breaking my entire system. Well, well, in version 2.0 I’ll replace this with a more robust encoding system.)
• The current output string. Stored in the first part of the URL, terminated by a ‘q’ (I’m having real trouble here with selecting characters unused in the program and all its possible states – otherwise matching would be a bitch)
• Did we rewrite anything in the last pass over the state? If nothing was rewritten, we must terminate the program. After the ‘q’ that terminates the output string, we store an ‘r’ before starting going through the rules and then every time we apply a rule we remove the ‘r’. If the ‘r’ is still there after having tried every rule in the program, we’re done and pass the output string to the printer PHP script.
• Finally, the current program state is stored after the q and r markers and goes on to the end of the URL.

In the end, this became something quite beautiful in its ugliness, although it could certainly need some robustness work. For example, it blindly relies on the Thue program to never ever use q or r anywhere (and probably a few other things I haven’t thought of). This should be changed to a totally robust encoding of anything that the rewrite rules should operate on as data, that can’t interfere with the things that are used as control structures and data formatting by the rewrite rules.

Here is the translator sed script in all its regexp-wtf glory, highlighted as Perl since GeSHi unfortunately doesn’t have sed highlighting.

# Remove comments
s/^#.*$//
# Rewrite question marks since they interfere with mod_rewrite by making the
# productions look like requests with query strings, which apache then splits.
s/\?/Q/g
# Escape characters with special meanings in regexps.
s/\([.*+(){}^$<>[\\ |]\|\]\)/\\\1/g
# Remove the ::= terminating line since it doesn't define a rule.
s/^::=$//
# Output rule: ~asf means to print the string "asf" and remove the matched string.
s/^\(.*\)::=~\(.*\)$/RewriteRule ^(.*)qr?(.*)\1(.*)$ $1\2q$2$3 [N]/
# Normal rule: match substring and replace it
s/^\(.*\)::=\(.*\)$/RewriteRule ^(.*)qr?(.*)\1(.*)$ $1q$2\2$3 [N]/

Note that the resulting rewrite rules are meant to be inserted into the mod_rewrite embedded language bootstrap I built in the previous post.