93

Say I have a List of object which were defined using lambda expressions (closures). Is there a way to inspect them so they can be compared?

The code I am most interested in is

    List<Strategy> strategies = getStrategies();
    Strategy a = (Strategy) this::a;
    if (strategies.contains(a)) { // ...

The full code is

import java.util.Arrays;
import java.util.List;

public class ClosureEqualsMain {
    interface Strategy {
        void invoke(/*args*/);
        default boolean equals(Object o) { // doesn't compile
            return Closures.equals(this, o);
        }
    }

    public void a() { }
    public void b() { }
    public void c() { }

    public List<Strategy> getStrategies() {
        return Arrays.asList(this::a, this::b, this::c);
    }

    private void testStrategies() {
        List<Strategy> strategies = getStrategies();
        System.out.println(strategies);
        Strategy a = (Strategy) this::a;
        // prints false
        System.out.println("strategies.contains(this::a) is " + strategies.contains(a));
    }

    public static void main(String... ignored) {
        new ClosureEqualsMain().testStrategies();
    }

    enum Closures {;
        public static <Closure> boolean equals(Closure c1, Closure c2) {
            // This doesn't compare the contents 
            // like others immutables e.g. String
            return c1.equals(c2);
        }

        public static <Closure> int hashCode(Closure c) {
            return // a hashCode which can detect duplicates for a Set<Strategy>
        }

        public static <Closure> String asString(Closure c) {
            return // something better than Object.toString();
        }
    }    

    public String toString() {
        return "my-ClosureEqualsMain";
    }
}

It would appear the only solution is to define each lambda as a field and only use those fields. If you want to print out the method called, you are better off using Method. Is there a better way with lambda expressions?

Also, is it possible to print a lambda and get something human readable? If you print this::a instead of

ClosureEqualsMain$$Lambda$1/821270929@3f99bd52

get something like

ClosureEqualsMain.a()

or even use this.toString and the method.

my-ClosureEqualsMain.a();
4
  • 1
    You can define toString, equals and hashhCode methods within closure. Jun 7, 2014 at 9:45
  • @AnkitZalani Can you give an example which compiles? Jun 7, 2014 at 9:46
  • @PeterLawrey, Since toString is defined on Object, I think you can define an interface that provides a default implementation of toString without violating the single-method requirement for interfaces to be functional. I haven't checked this though. Jun 7, 2014 at 15:45
  • 9
    @MikeSamuel That's incorrect. Classes do not inherit default Object methods declared in interfaces; see stackoverflow.com/questions/24016962/… for explanation. Jun 8, 2014 at 0:20

3 Answers 3

98
+300

This question could be interpreted relative to the specification or the implementation. Obviously, implementations could change, but you might be willing to rewrite your code when that happens, so I'll answer at both.

It also depends on what you want to do. Are you looking to optimize, or are you looking for ironclad guarantees that two instances are (or are not) the same function? (If the latter, you're going to find yourself at odds with computational physics, in that even problems as simple as asking whether two functions compute the same thing are undecidable.)

From a specification perspective, the language spec promises only that the result of evaluating (not invoking) a lambda expression is an instance of a class implementing the target functional interface. It makes no promises about the identity, or degree of aliasing, of the result. This is by design, to give implementations maximal flexibility to offer better performance (this is how lambdas can be faster than inner classes; we're not tied to the "must create unique instance" constraint that inner classes are.)

So basically, the spec doesn't give you much, except obviously that two lambdas that are reference-equal (==) are going to compute the same function.

From an implementation perspective, you can conclude a little more. There is (currently, may change) a 1:1 relationship between the synthetic classes that implement lambdas, and the capture sites in the program. So two separate bits of code that capture "x -> x + 1" may well be mapped to different classes. But if you evaluate the same lambda at the same capture site, and that lambda is non-capturing, you get the same instance, which can be compared with reference equality.

If your lambdas are serializable, they'll give up their state more easily, in exchange for sacrificing some performance and security (no free lunch.)

One area where it might be practical to tweak the definition of equality is with method references because this would enable them to be used as listeners and be properly unregistered. This is under consideration.

I think what you're trying to get to is: if two lambdas are converted to the same functional interface, are represented by the same behavior function, and have identical captured args, they're the same

Unfortunately, this is both hard to do (for non-serializable lambdas, you can't get at all the components of that) and not enough (because two separately compiled files could convert the same lambda to the same functional interface type, and you wouldn't be able to tell.)

The EG discussed whether to expose enough information to be able to make these judgments, as well as discussing whether lambdas should implement more selective equals/hashCode or more descriptive toString. The conclusion was that we were not willing to pay anything in performance cost to make this information available to the caller (bad tradeoff, punishing 99.99% of users for something that benefits .01%).

A definitive conclusion on toString was not reached but left open to be revisited in the future. However, there were some good arguments made on both sides on this issue; this is not a slam-dunk.

28
  • 6
    +1 While I understand supporting == equality is a hard problem to solve generally, I would have thought there would be simple cases where the compiler, if not the JVM could recognise that this::a on one line is the same as this::a on another line. In fact it is still not obvious to me what you gain by giving every call site it's own implementation. Perhaps they can be optimised differently, but I would have thought inlining could do this.?? Jun 7, 2014 at 23:17
  • 8
    We investigated a number of possible implementations, including one one in which the proxy classes were shared across callsites. The one we went with for now (one big benefit of the "metafactory" approach is that this can be changed without recompiling user classfiles) was the simplest and best-performing. We'll continue to monitor relative performance between options as the VM evolves, and when one of the others is faster, we'll switch. Jun 8, 2014 at 0:18
  • 6
    No changes for Java 9. Feb 11, 2017 at 17:22
  • 3
    @GeoffreyDeSmet I am sure it was done with good intentions, but it happens so often that developers perceive they have "no choice" when performance is pitted against safety or maintainability. This is, as you suggest, likely amplified by the fact that the security concerns are not as well understood (though, when performance is concerned, it is sometimes hard to get people to listen to the other concerns.) Mar 29, 2021 at 19:28
  • 3
    @GeoffreyDeSmet the missing possibility to validate data is one problem, but since lambda expressions and method references primarily encapsulate behavior, the bigger problem is that serialization allows to get access to that behavior for arbitrary (untrusted code). This question contains a practical example.
    – Holger
    Apr 14, 2021 at 7:25
7

To compare labmdas I usually let the interface extend Serializable and then compare the serialized bytes. Not very nice but works for the most cases.

1
  • The same applies to hashCode of lambdas, doesn't it? I mean serializing a lambda to a byte array (with the help of ByteArrayOutputStream and ObjectOutputStream) and hashing it by Arrays.hash(...).
    – mmirwaldt
    Apr 6, 2019 at 13:11
6

I don't see a possibility, to get those informations from the closure itself. The closures doesn't provide state.

But you can use Java-Reflection, if you want to inspect and compare the methods. Of course that is not a very beautiful solution, because of the performance and the exceptions, which are to catch. But this way you get those meta-informations.

1
  • 1
    +1 reflection allows me to get this as arg$1 but not compare the method called. I may need to read the byte code to see if it is the same. Jun 7, 2014 at 10:42

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.