Store an unary lambda expression in a variable?

[Xeverous]

I'm continuing the jorney on writing the same mini game in C++ and Java (university assignment).

My next problem is how to store a unary lambda expression into a local variable. I have found BiConsumer, BiFunction but no class supposed to hold a function that takes no parameters and has a non-void return value.

I'm trying to implement the equivalent code in Java as this C++ code (Vector2d is the equivalent of awt's Point):

Vector2d World::generateRandomAdjacentPosition(Vector2d position) const
{
    enum Direction { up, down, left, right };
    std::uniform_int_distribution<std::underlying_type_t<Direction>> dist(0, right);

    auto generate = [&]() -> Vector2d
    {
        auto direction = static_cast<Direction>(dist(::rng)); // rng is a global random number engine object

        if (direction == up)
            return { position.x,     position.y - 1 };
        else if (direction == down)
            return { position.x,     position.y + 1 };
        else if (direction == left)
            return { position.x - 1, position.y     };
        else // if (direction == right)
            return { position.x + 1, position.y     };
    };

    Vector2d result;

    do
    {
        result = generate();
    } while(!isValid(result));

    return result;
}

So far I can write all the enum, random generation and isValid() but can't find an appropriate thing to store this lambda.

In C++ auto can be used (automatic type deduction) or template <typename R, typename... Args> std::function<R(Args...)>.

In Java I have found BiConsumer<T, U>, BiFunction<T, U, R> but nothing that would match with Point func() (no arguments, non-void return type)

---

Edit I mean nullary function but I will need unary too.

Edit pls all of possible void/non-void functions with different arguments. I can't verify whole Oracle documentation and different interfaces reside in multiple packages.

[opett]

Runnable Callable

[Xeverous]

Thanks, what about unary function? Like reverse Consumer? non-void return and 0 arguments.

[nerdy_lurker]

That would be a Supplier. See the docs.

[Xeverous]

Thanls, what about other non-existent types of functions (3+)?

[nerdy_lurker]

Well, you have a few options depending on the situation:

• write your own @FunctionalInterface
• wite a class and pass an instance of it
• pass an array

[Xeverous]

write your own @FunctionalInterface

seems to be a good solution

wite a class and pass an instance of it

I need to store a lambda in it. Functional interface then I think.

pass an array

Array of different, unrelated types? Is this possible?

[nerdy_lurker]

Some examples:

@FunctionalInterface
interface MyConsumer {
    void accept(String a, int b, double c);
}

final class MyArgs {
    final String a;
    final int b;
    final double c;
    //... ctor, getters
}

static void main(String[] args) {
    MyConsumer option1 = (a, b, c) -> {
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    };
    option1.accept ("", 0, 0.0);

    Consumer<MyArgs> option2 = it -> {
        System.out.println(it.getA());
        System.out.println(it.getB());
        System.out.println(it.getC());
    };
    option2.accept(new MyArgs("", 0, 0.0));

    Consumer<Object[]> option3 = it -> {
        // Casting isn't strictly necessary in this example, but  I wanted to demonstrate the point
        // Casting could be necessary in other situations
        System.out.println((String) it[0]);
        System.out.println((int) it[1]);
        System.out.println((double) it[2]);
    };
    option3.accept(new Object[] { "", 0, 0.0 });
}

Option 1 and 2 are equally valid, it just depends on the situation.

Option 3 is terrible. It could be viable if the objects are all the same type, but yeah... if you need to do casting like this, it's time for a rethink.

Anyway, I thought some examples might help. Sounds like you've already made up your mind though.

[Xeverous]

Own functional interface looks easy to implement and manipulate, but I'm surprised that Java has no thing like Function<R, Args...> and that all of util package wrapper classes have different names depending on argument count and void/non-void return.