Upgrade Regex with a tester() method?

Peter Levart peter.levart at gmail.com
Mon Jan 21 09:20:26 PST 2013

On 01/21/2013 10:25 AM, Paul Sandoz wrote:
> On Jan 20, 2013, at 7:04 PM, Peter Levart <peter.levart at gmail.com> wrote:
>> On 01/04/2013 04:07 PM, Brian Goetz wrote:
>>> Seems a nice "point lambdafication" suggestion.  (The naming convention
>>> we've been using as "asPredicate()".)
>>> Regex is one of those areas where we wanted to do more with
>>> lambdafication, but just didn't have the time to work through it.  If
>>> you want to suggest more...
>> If that is being considered, I would suggest to include all 3 variants
>> of matching (corresponding to 3 methods of Matcher):
>> public Predicate<String> asFindPredicate()
>> public Predicate<String> asLookingAtPredicate()
>> public Predicate<String> asMatchesPredicate()
>> Without "as" might even sound better since there are three of them:
>> public Predicate<String> findPredicate()
>> public Predicate<String> lookingAtPredicate()
>> public Predicate<String> matchesPredicate()
> I question whether such methods carry enough weight, given that it is really easy to state:
>   () -> p.find()
> or
>   Pattern::find
Well, it's a little longer:

(s) -> p.matcher(s).find()

But I agree, those are to simple expressions to carry a weight for 
introduction of a new method...

Another possible point lambdafication is an idiom that is frequent with 
using pattern matching - replacement:

public class Pattern { ...

     public String replaceAll(String str, Function<String, String> 
replacementFunction) {
         Matcher m = matcher(str);
         StringBuffer sb = new StringBuffer();
         while (m.find()) {
             m.appendReplacement(sb, replacementFunction.apply(m.group(1)));
         return sb.toString();

so one can write:

         Pattern pattern = Pattern.compile("\\{(.*?)\\}");
         String msg = pattern.replaceAll(
             "User's home is: {user.home}, current dir is: {user.dir}",

This method could then also be overloaded on String as a shortcut 
without precompiled Pattern instance:

public class String {...

     public String replaceAll(String regex, Function<String, String> 
replacementFunction) {
         return Pattern.compile(regex).replaceAll(this, 

so one could write:

     String msg = "User's home is: {user.home}, current dir is: {user.dir}"
                      .replaceAll("\\{(.*?)\\}", System::getProperty);

Regards, Peter

> My preference is to encourage usage of such expressions rather than pick some boolean returning zero parameter methods of some classes to be "overloaded" with Predicate-based alternatives.
> Paul.

More information about the lambda-dev mailing list