Getting parameters and return value of lambda

Question

I have an interface which is

public static interface MyClass{
    public boolean doSomething(boolean a, boolean b);
}

I then instantiate a variable

MyClass a = (boolean x, boolean y) -> x && y;

Now my question is that if I want to get the parameters x and y and the return value, how would I go about doing that? The reason I want to get the parameters is because I want to serialize so that I am able to do a ObjectOutputStream.writeObject() with them.

Not sure if my question fully makes sense. I haven't worked with lambda too much so any sort of guidance will be greatly appreciated.

Adding On: OK so MyClass a is instantiated in another class, let's call it ParentClass. So now I have

MyClass a = (x, y) -> x && y;
    ParentClass b = new ParentClass();
    b.setMyClass(a);

Now in the main class that I am working in, I get passed ParentClass b. So I take it and do MyClass c = b.getMyClass; Which if I understand correctly is a reference to (x, y) -> x && y;. Now the question is, how do I get the values of the parameters and return value so that I can serialize it. Also MyClass will not always be (x,y) -> x && y, it could be anything i.e

MyClass a = (x, y) -> x || y;
MyClass a = (x, y) -> x^y;
MyClass a = (x, y) -> true;

I'm not allowed to modify MyClass or ParentClass. Which is why I was trying to get the parameters passed and the return value so that I could serialize those and send them through.

Answer 1

I suspect you are misunderstanding how lambda expressions work. Your question implies that you are expecting to create your a object and then serialize it and in the process somehow record the values of x and y. Have I understood you correctly?

If so then this is fundamentally not how lambdas work. They are not an object containing state in the ordinary sense. Rather think of them as a bit of executable code that you can pass around that can be applied to a set of values whenever you want (I suspect I'll be hammered in the comments for that overly simplistic explanation!).

You can serialize lambdas but in that case you are serializing the operation represented by the lambda, not the values passed to it in any given invocation.

If you want implementations of the MyClass interface to be serializable then it needs to extend Serializable. It should look as follows:

@FunctionalInterface
public interface MyClass extends Serializable {
    boolean doSomething(boolean a, boolean b);
}

If you can't modify MyClass then you can still cast a MyClass object to Serializable:

Serializable a = (Serializable & MyClass)(a, b) -> a || b;

Or if you are using the value from a ParentClass:

Serializable a = (Serializable)b.getMyClass();

You should then be able to serialize a.

Just remember when you deserialize that you need to cast back to MyClass so that you can use it. It will look something like:

MyClass b = (Serializable & MyClass)objectInStream.readObject();
b.doSomething(true, false);

Answer 2

In Java, the lambda syntax is, simply, a way to describe the behaviour of a method without giving it a name.

e.g. (Type1 arg1, Type2 arg2, ...) -> <expression> defines a function looking something like this:

public TypeOfExpression anonymousMethod(Type1 arg1, Type2 arg2, ...) {
    ...
    return <expression>;
}

Look on the Java Tutorials for more info on lambdas.

In fact the lambda expression (boolean x, boolean y) -> x && y (when given type MyClass as you define it) is nothing but syntactic sugar for the following:

new MyClass() {
    public boolean doSomething(boolean x, boolean y) {
        return x && y;
    }
}

Hopefully that gives some clarity into what lambdas are representing in Java.

In technical terms, the interface definition you gave defines a 'function type'. In Java, any interface which has only a single method is called 'functional', and can be used, instead of as an interface, as the type of a lambda expression of the same type as the single method in the interface.

This decision was presumably made because if an interface has only one method, all that is needed to specify it is the behaviour of that method, which can be far more concisely written in the lambda notation, as demonstrated above.

So, the lambda expression is nothing but an instance of your interface - in particular, it has no fields, but defines a method behaviour. I think you are assuming instead that it encapsulates a pair of inputs and their output result. If this is what you need, you might be looking for something more like a pair type with a built in operation (like && in this case).

EDIT: on serializability.

It's apparent that you require serialization of an unknown function of MyClass type. If MyClass extends Serializable, you should be able to cast appropriately and serialize. If you're not in control of MyClass, so can't ensure this, the following ad hoc observation may help.

If the method in MyClass is indeed of the type shown here (boolean, boolean) -> boolean, there are a small enough number of cases to consider that you can manually serialize.

The number of 'possible' (total) functions of type A -> B, for finite-sized types A and B is |B|^|A| (size of B to the power size of A). This is because, counting the possible functions, for each input of type A there are |B| possible outputs the function could give.

Also, the size of the pair type (A, B) is |A|*|B|.

In our case, we have (boolean, boolean) -> boolean. But boolean is only of size 2! So (boolean, boolean) is of size 4, and (boolean, boolean) -> boolean is of size 2^4 = 16.

How do we work out which of these 16 functions we have on our hands? Simply enumerate through the possible inputs (only 4 to do). Then we can record the four outputs in variables something like this (where a will be our unknown function.)

boolean ttout = a(true, true);
boolean tfout = a(true, false);
boolean ftout = a(false, true);
boolean ffout = a(false, false);

Then we can merrily serialize these four values. :)

Further, if we are deserializing and obtain the four values (ttout, tfout...) we can reconstruct the function something like this:

a = (boolean x, boolean y) -> {
    if (x) {
        if (y) return ttout;
        else return tfout;
    } else {
        if (y) return ftout;
        else return ffout;
    }
}

Answer 3

If you want a itself to be serializable, you can write a = (MyClass & Serializable) (boolean x, boolean y) -> x && y.

There is no x or y just from the definition of a, though: those only exist when a is actually invoked.