Non-Trivial Predicate Combination in java.util.function

[Jesse Silverman]

I was elated and horrified to see the scope of functional programming covered in Chapter 4 in Jeanne and Scott's book.
Horrified, because there was so much in there.
Then elated, because I want to know all that stuff anyway, so now I have an excuse to tell my wife, next boss, etc.-- thank you OCJP.

Anyway, both the book and a tutorial video I watched were a bit skimpy on details of how .and() and .or() really worked.

I had two questions immediately upon seeing them:
a. Short Circuit or Not?
b. Do we get the equivalent of operator precedence so that just chaining .and() and .or() is the same thing as writing expressions with && and || ?

A quick glance at the docs told me "Yes" for the first part.  Not quick enough, I had already written noisy methods to demonstrate the answer to (a) visually.

I stared at it until I was going cross-eyed, and couldn't tell the answer to (b) from the docs.  It seemed like it would potentially be possible to do, but beyond what an API would be expected to do.  So my guess was "No" for part B but after reviewing the tutorial video and the chapter material it seemed to still be ambiguous.

I threw together the following quick little demo to show the answer to (b).  It does make use of method references as well, primarily because I wanted to be able to have a "noisy" version that illustrated the calls (commented out below).  It looks like this:

package org.jessesilverman.compoundPredicates;
import java.util.ArrayList;
import java.util.function.*;
import static java.util.function.Predicate.not;

public class CompoundPredicates {
	public static boolean beginsWithVowel(String s)	// Y is considered a vowel
	{
		//System.out.println("BWV called");
		if (null == s || s.length() < 1) return false;
		char chr = Character.toLowerCase(s.charAt( 0 ) );
		return chr == 'a' || chr == 'e' ||
				   chr == 'i' || chr == 'o' ||
				   chr == 'u' || chr == 'y';
	}
	
	public static boolean endsWithVowel(String s) // Y is considered a vowel
	{
		//System.out.println("EWV called");
		if (null == s || s.length() < 1) return false;
		char chr = Character.toLowerCase(s.charAt( s.length() - 1 ) );
		return chr == 'a' || chr == 'e' ||
				   chr == 'i' || chr == 'o' ||
				   chr == 'u' || chr == 'y';
	}
	
	public static boolean isShort(String s)
	{
		//System.out.println("Testing Length");
		return s.length() < 5;
	}
	
	public static void complexPredicateExample()
	{
		ArrayList<String> als = new ArrayList<>();
		// show how .and() and .or() work with composed predicates
		als.add("Ace"); 	 // S+ BV+ EV+
		als.add("Bop"); 	 // S+ BV- EV-
		als.add("And");		 // S+ BV+ EV-
		als.add("Doo");		 // S+ BV- EV+
		als.add("Alfredo");  // S- BV+ EV+
		als.add("Childish"); // S- BV- EV-
		als.add("Untested"); // S- BV+ EV-
		als.add("Porcupine");// S- BV- EV+

		
		Predicate<String> beginsWithVowel = CompoundPredicates::beginsWithVowel;
		
		Predicate<String> isShort = CompoundPredicates::isShort;
		
		Predicate<String> endsWithVowel = CompoundPredicates::endsWithVowel;


		System.out.println("Strings beginning with a vowel:");
		for (String string: als)
		{
			if ( beginsWithVowel.test( string) )
				System.out.println( string );
		}
		
		System.out.println("Strings that are short:");
		for (String string: als)
		{
			if ( isShort.test( string) )
				System.out.println( string );
		}
		
		System.out.println("Strings that are short and also begin with a vowel:");
		for (String string: als)
		{
			if ( beginsWithVowel.and(isShort).test( string ) )
				System.out.println( string );
		}
		
		System.out.println("Strings that are short OR begin with a vowel:");
		for (String string: als)
		{
			if ( beginsWithVowel.or(isShort).test( string ) )
				System.out.println( string );
		}
		/*
		*/
		// whereas when using raw logical short-circuit operators,
		// precedence naturally happens within the expression,
		// when using .and() and .or() with predicates there are implied parenthesis
		// around each stage of the composition.  This means that: 
		// p1.or(p2.and(p3)).test() means (p1 || p2 && p3) due to explicit parens!
		// but p1.or(p2).and(p3).test() == (p1 || p2) && p3
		// Proof: p1 = bwv, p2 = isS, p3 = ewv
		// we will show that:
		// 1. p1.or(p2.and(p3)).test() == (p1 || p2 && p3).test()
		// 2. p1.or(p2).and(p3).test() == (p1 || p2) && p3
		
		System.out.println("Strings that are short OR both begin and end with a vowel:");
		System.out.println("Should be: Ace, Bop, And, Doo, Alfredo");
		for (String string: als)
		{
			if ( isShort.or(beginsWithVowel.and(endsWithVowel)).test( string ) )
				System.out.println( string );
		}
		
		System.out.println(
				"Strings that (are short OR begin with a vowel) AND end with vowel:");
		System.out.println("Should be: Ace, Doo, Alfredo");
		for (String string: als)
		{
			if ( isShort.or(beginsWithVowel).and(endsWithVowel).test( string ) )
				System.out.println( string );
		}
		
		System.out.println(
				"Strings that end with vowel AND (are short OR begin with a vowel):");
		System.out.println("Should be: Ace, Doo, Alfredo");
		for (String string: als)
		{
			if ( endsWithVowel.and(isShort.or(beginsWithVowel)).test( string ) )
				System.out.println( string );
		}
		
		System.out.println("Strings that are not short and neither begin nor end with a vowel:");
		for (String string: als)
		{
			if ( isShort.or(beginsWithVowel).or(endsWithVowel).negate().test( string ) )
				System.out.println( string );
		}
		
		System.out.println("Strings that are not short and neither begin nor end with a vowel:");
		// warning: Java 11+ only!!
		for (String string: als)
		{
			if ( not( isShort.or(beginsWithVowel).or(endsWithVowel) ).test( string ) )
				System.out.println( string );
		}
		
	}
	public static void main( String... arrrggh)
	{
		complexPredicateExample();
	}
}

Literally, just walking away from this I couldn't remember where it made a difference, but knew it did.
This program highlights the difference between the normal short-circuit expression:
T || F && F ==> T
and the composed predicate:
T.or( F ).and( F) ==> F

I don't know if this is quite in scope for the 819 exam or not, but my brain wouldn't let me focus on other things until I understood the answer to by doubt in (b) anyway.

Lastly, I threw in a neat convenience static method new to Java 11+ at the end, to prove I read the docs.  It took me a little while to figure out exactly how to call it.
I think it makes more sense and results in more literate code.  The old way of reversing the polarity of a complex predicate combination was clear and readable, NOT!
Oh wait, that is already a nerdy joke trope, no doubt suggesting the static convenience method we got in Java 11.
Comment it out if you are running with Java 8, 9 or 10.

[Piet Souris]

Predicates are calculated left to right. To be sure if in doubt, use parentheses if you want some other order of execution, like

var p = p1.or(p2.and(p3));

[Jesse Silverman]

So my confusion can be summarized thusly.
When I heard "predicate combination with .or() and .and() short circuits"
I thought....great, that can save a lot of time, since....

true || false && false && false && false && false && false && false
just evaluates to true without testing the other N conditions...

it sounds like maybe:
pTrue.or(pFalse).and(pFalse).and(pFalse).and(pFalse).and(pFalse).and(pFalse).and(pFalse)
is gonna do the same thing for me!  They said "short circuit, right?"

Putting my noisy predicates back in, I see that I over-estimated what short-circuit means, the scope of short-circuit is limited to pairwise comparisons, different to "normal expressions with operators":

		if (isShort.or(beginsWithVowel).and(endsWithVowel).test( "Dumb" ) )
			System.out.println( "You had it right!!" );
		else System.out.println("You were confused by what short-circuit meant with chained predicates!");

Yields of course, because I *was* confused:
Testing Length
EWV called
You were confused by what short-circuit meant with chained predicates!

The precedence that || and && have doesn't carry over to chained predicates, so short-circuit means less than I thought.

I get it now, but there's no way it would have got into my thick skull from two presentations and a read of the docs.

[Jesse Silverman]

Thanks, Piet!

I normally use parentheses liberally to avoid confusion, as mentioned in other threads, but on the exams they are treated like rare, valuable commodities to ensure we really understand the order of precedence.

Sure a.plus(b).times(c) is the same as (a + b) * c
but the promise of "short-circuit evaluation" made me think that something different was going to happen with predicate chaining.

It does not.

[Piet Souris]

You're welcome!

Here is a way to test short circuiting a bit easier. Expand as needed:

public class PredicateAndOr {
    public static void main(String... args) {
        Predicate<Integer> e = i -> {
            System.out.println("e tested");
            return i % 2 == 0;
        };
        Predicate<Integer> t = i -> {
            System.out.println("t tested");
            return i % 3 == 0;
        };
        Predicate<Integer> f = i -> {
            System.out.println("f tested");
            return i % 5 == 0;
        };
        var p1 = e.or(t).and(f);
        var p2 = (e.or(t)).and(f);
        var p3 = e.or(t.and(f));
        System.out.println("p1 = " + p1.test(2));
        System.out.println("p2 = " + p2.test(2));
        System.out.println("p3 = " + p3.test(2));
    }
}

[Jesse Silverman]

I feel that now that I understand that in the case of Predicate Chaining, (but not normal boolean expressions) short-circuiting is limited to a single invocation of .and() or .or() I don't need it anymore.

That may help someone else who might be sharing the same confusion that I had in the future, tho.

Even as a kid, I'd get the hardest questions on the test right and be stumped on the easiest ones, so maybe it is just me.

[Piet Souris]

Jesse Silverman wrote:so maybe it is just me.

Don't worry. That line should read: so it is just nearly all of us.

[Jeanne Boyarsky]

Knowing it exists in scope. The level of detail you described is not.

I gave you a cow for the awesome description though. Even though you don't need it for the exam, it is useful info!