Skip Menu |
 

This queue is for tickets about the Regexp-Assemble CPAN distribution.

Report information
The Basics
Id: 16588
Status: resolved
Worked: 15 min
Priority: 0/
Queue: Regexp-Assemble

People
Owner: dland [...] cpan.org
Requestors: jpierce [...] cpan.org
Cc:
AdminCc:

Bug Information
Severity: (no value)
Broken in: 0.22
Fixed in: (no value)



Subject: mutable has unintended side-effects
Download (untitled) / with headers
text/plain 219b
See http://web/belg4mit/www/18/, basically mutable yields unoptimized expressions. Also, mutability is probably the DWIM behavior (were the above bug not the case) and it's clear why one would want to set immutability.
Download (untitled) / with headers
text/plain 1.9k
[JPIERCE - Sun Dec 18 20:23:59 2005]: Show quoted text
> See http://web/belg4mit/www/18/, basically mutable yields unoptimized > expressions. > > Also, mutability is probably the DWIM behavior (were the above bug not > the case) and it's clear why one would want to set immutability.
It is actually working as advertised, which leads me to conclude that the documentation sucks. There are two contradicting forces at work here. Firstly: performing the assembly transforms the internal data structure so radically that it is no longer possible to add new patterns in any sane manner. Secondly: in a long-running program, you might want to add a few patterns, assemble the result, add a few more, assemble the result and so on until the end of time, or until the program halts, whichever comes first. So to reconcile these two opposing forces, I came up with the idea of raising a flag to say that we want to assemble a pattern, but we also want to be able to continue to add patterns afterwards. That's what mutable is for: we want to keep changing it. Since we want to be able to change it, we cannot reduce the data structure, because then we cannot add new patterns. And since the data structure isn't reduced, the trie optimisation isn't run, and the patterns come out with only prefix reductions performed. Usually that's good enough, because in doing so you save a few cycles by skipping the reduction code and a pattern, if not the shortest pattern, is returned faster. There is a way, though, of having your cake and eating it. You just clone() the pattern at time t and reduce the copy. This allows you to continue to add to the orginal, since its internal data structure wasn't subjected to stresses of assembly. A rough sketch of the code would look like: my $master = Regexp::Assemble->new; while (my $pattern = get_another_pattern()) { $master->add( $pattern ); my $copy = $master->clone; print $copy->as_string, "\n"; } ... for some definition of get_another_pattern(). Hope this helps.


This service is sponsored and maintained by Best Practical Solutions and runs on Perl.org infrastructure.

Please report any issues with rt.cpan.org to rt-cpan-admin@bestpractical.com.