Overloading of methods that take Functional interfaces as parameters.

[Chan Ag]

Isn't overloading of methods that take Functional interfaces as parameters a risky thing. What if the classes, in which these overloaded methods are present, coded much before such interfaces are actually created.

Consider this.

package lambdaexpressions;

import java.time.LocalDate;
import java.time.chrono.IsoChronology;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class Person {
  
    public enum Sex 
    {
        MALE, FEMALE
    }
  
    private String name; 
    private LocalDate birthday;
    private Sex gender;
    private String emailAddress;
  
    Person(String nameArg, LocalDate birthdayArg,
        Sex genderArg, String emailArg) 
    {
        name = nameArg;
        birthday = birthdayArg;
        //birthday = birthdayArg.minusYears(5);
        gender = genderArg;
        emailAddress = emailArg;
    }  

    public int getAge() 
    {
        return birthday
            .until(IsoChronology.INSTANCE.dateNow())
            .getYears();
    }

    public void printPerson() 
    {
      System.out.println(name + ", " + this.getAge());
    }
    
    public Sex getGender() 
    {
        return gender;
    }
    
    public String getName() 
    {
        return name;
    }
    
    public String getEmailAddress() 
    {
        return emailAddress;
    }
    
    public LocalDate getBirthday() 
    {
        return birthday;
    }
    
    public static int compareByAge(Person a, Person b) 
    {
        return a.birthday.compareTo(b.birthday);
    }

    public static List<Person> createRoster() 
    {
        
        List<Person> roster = new ArrayList<>();
        roster.add(
            new Person(
            "Fred",
            IsoChronology.INSTANCE.date(1980, 6, 20),
            Person.Sex.MALE,
            "[e-mail]"));
        roster.add(
            new Person(
            "Jane",
            IsoChronology.INSTANCE.date(1990, 7, 15),
            Person.Sex.FEMALE, "[e-mail]"));
        roster.add(
            new Person(
            "George",
            IsoChronology.INSTANCE.date(1991, 8, 13),
            Person.Sex.MALE, "[e-mail]"));
        roster.add(
            new Person(
            "Bob",
            IsoChronology.INSTANCE.date(2000, 9, 12),
            Person.Sex.MALE, "[e-mail]"));
        
        return roster;
    }
    
   
     public static <P,S> void performAction2(List<P> roster, 
             Predicate<P> criteria,
             Function<P, S> mapper,
             Consumer<S> action)   
     {
         for ( P p : roster) 
         {
             if (criteria.test(p))
             {
                 S message = mapper.apply(p);
                 action.accept(message);
             }
         }
     }
     
     public static <P,S> void performAction2(List<P> roster, 
             Predicate2<P> criteria,
             Function<P, S> mapper,
             Consumer<S> action)   
     {
         for ( P p : roster) 
         {
             if (criteria.test(p))
             {
                 S message = mapper.apply(p);
                 action.accept(message);
                 System.out.println("Second one");
             }
         }
     }
    

Most of the code in the above class is from http://docs.oracle.com/javase/tutorial/displayCode.html?code=http://docs.oracle.com/javase/tutorial/java/javaOO/examples/Person.java ( This is copied as is-- so why the createRoster() method is in Person class and other such questions - let us ignore them for now).

Now as we see, I have two overloaded methods with the name performAction2. The only difference is one of them takes a Predicate

parameter and the other one takes Predicate2

parameter. The compiler allows this.

I created Predicate2<T>by copying the source code of Predicate<T> and changing all references of Predicate to Predicate2.

Now I can't use Lambda expressions to call them.
If I call them as follows using Lambda expression syntax,

package lambdaexpressions;

public class Approach8 {
	
	public static void main(String [] args)	
        {
		Person.performAction2(Person.createRoster(), 
				p -> p.getGender() == Person.Sex.MALE &&
					p.getAge() >= 18 &&
					p.getAge() < 25,
				p -> p.getEmailAddress(),			
				email -> System.out.println(email));  
	}

}

I get the following compilation error.

The method performAction2(List<Person>, Predicate<Person>, Function<Person,Object>, Consumer<Object>) is ambiguous for the type Person.

Shouldn't the Lambda expression syntax have been different? I mean why should lambda expressions syntax have no way of specifying which interface is being implemented? What do you think?

[Chan Ag]

Ok, This must be ok cause we can use the anonymous classes or local classes or just implementing classes type syntax to invoke these methods.

We should have no reason to duplicate such functional interfaces ( they are interfaces after all ) and if we at all have to create a similar interface for some weird reason, then we can't use lambda expressions to invoke such overloaded methods. It's not like those methods are going to become useless. We can still use implementing classes and the old, evergreen syntax.

I guess I posted this question too early.

[Rob Spoor]

You can use a reference instead:

package lambdaexpressions;  
  
public class Approach8 {  
    public static void main(String [] args) {
        Predicate<Person> predicate = p -> p.getGender() == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() < 25;
        Person.performAction2(Person.createRoster(),
                predicate, 
                p -> p.getEmailAddress(),              
                email -> System.out.println(email));    
    }  
}

[Chan Ag]

Awesome. Thanks, Rob.

I should have tried this. But this didn't even strike me.

[Rob Spoor]

You're welcome.

[Scott Shipp]

Chan Ag wrote:
We should have no reason to duplicate such functional interfaces ( they are interfaces after all ) and if we at all have to create a similar interface for some weird reason, then we can't use lambda expressions to invoke such overloaded methods. It's not like those methods are going to become useless. We can still use implementing classes and the old, evergreen syntax.

Hi Chan...I don't know if I am reading you right here. But I wanted to mention that you can create your own interfaces and invoke them with lambda expressions. Example here, I've created the "Generator" interface in lines 1-3, I pass it as the fourth parameter in the "generateSeries" method on line 5, and down in line 24 I pass a Lambda expression into it:

  interface Generator {
		double calculateNthInSeries(int n);
	}

	public static List<String> generateSeries(int startingFrom, int howMany, Function<Double, String> format, Generator g) {
		List<String> l = new ArrayList<>();
		String nextInSeries;
		for(int i = startingFrom; i < startingFrom + howMany; i++) {
			nextInSeries = format.apply(g.calculateNthInSeries(i));
			l.add(nextInSeries);
		}
		return l;
	};
	
	public static void main(String[] args) {
		String ListSeparator = "";
		DecimalFormat myFormat = (DecimalFormat)NumberFormat.getNumberInstance(Locale.ENGLISH);
		myFormat.applyPattern("#");
		
		myFormat.applyPattern("#.#####");
		System.out.printf("%n%nAreas of circles with radii from 1 to 10:%n");

                //Notice the use of Lambda here even though it is my own interface
		generateSeries(1, 10, f -> myFormat.format(f), n -> Math.PI * n * n).stream().forEach(e -> System.out.printf("%s  ", e));
	}