Return value from capability

[Alpvax]

Is it just me, or is the LazyOptional very awkward to use?

The isPresent() function seems virtually useless, what does it offer over doing .orElse(null), followed by a null check, because you cannot get the value without using orElse anyway?

 

It seems that there is no easy way to return a value from a capability that may not be present. For example:

interface CapabilitySample {
  int amount();
  int amountMultiplier();
}

//In another class:
public int getAmount(ICapabilityProvider obj) {
	LazyOptional<CapabilitySample> cap = obj.getCapability(Capability_Instance);
   
  //************** Option 1 **************
    // Works if you only need a single method from the capability
    return cap.map(CapabilitySample::amount).orElse(0);
    //But what if you need multiple methods? The following (mapping the capability twice) seems like a bad idea:
    return cap.map(CapabilitySample::amount).orElse(0) * cap.map(CapabilitySample::amountMultiplier).orElse(1);
  
  //************** Option 2 **************
    if (cap.isPresent()) {
        //How do I return cap.amount() from here? There is no way to retrieve the cap.value().
        //Do I really have to do the following?
        CapabilitySample value = cap.orElseThrow(()-> new Exception("Pointless exception which can never happen!"));
        return value.amount() * value.amountModifier();
    } else {
        return 0;
    }

  //************** Option 3 **************
    //Requires an entire implementation to be written with dummy methods!
    CapabilitySample value = cap.orElse(dummyCapabilitySample);
    return return value.amount() * value.amountModifier();
}

 

Am I missing something, or is this a big oversight? Am I using capabilities wrong? Am I not supposed to return values from them, and just go all-in functional?

 

As an unrelated aside, I also find the capability default implementation factory impossible to use, because invariably I want to use the object I am attaching to to set up the capability.

[Novârch]

21 minutes ago, Alpvax said:

Is it just me, or is the LazyOptional very awkward to use?

The isPresent() function seems virtually useless, what does it offer over doing .orElse(null), followed by a null check, because you cannot get the value without using orElse anyway?

 

It seems that there is no easy way to return a value from a capability that may not be present. For example:

interface CapabilitySample {
  int amount();
  int amountMultiplier();
}

//In another class:
public int getAmount(ICapabilityProvider obj) {
	LazyOptional<CapabilitySample> cap = obj.getCapability(Capability_Instance);
   
  //************** Option 1 **************
    // Works if you only need a single method from the capability
    return cap.map(CapabilitySample::amount).orElse(0);
    //But what if you need multiple methods? The following (mapping the capability twice) seems like a bad idea:
    return cap.map(CapabilitySample::amount).orElse(0) * cap.map(CapabilitySample::amountMultiplier).orElse(1);
  
  //************** Option 2 **************
    if (cap.isPresent()) {
        //How do I return cap.amount() from here? There is no way to retrieve the cap.value().
        //Do I really have to do the following?
        CapabilitySample value = cap.orElseThrow(()-> new Exception("Pointless exception which can never happen!"));
        return value.amount() * value.amountModifier();
    } else {
        return 0;
    }

  //************** Option 3 **************
    //Requires an entire implementation to be written with dummy methods!
    CapabilitySample value = cap.orElse(dummyCapabilitySample);
    return return value.amount() * value.amountModifier();
}

 

Am I missing something, or is this a big oversight? Am I using capabilities wrong? Am I not supposed to return values from them, and just go all-in functional?

 

As an unrelated aside, I also find the capability default implementation factory impossible to use, because invariably I want to use the object I am attaching to to set up the capability.

LazyOptional.ifPresent(props -> {}) is what you want, props will be an instance of your capability. Here's an example of how I use it.

Edited May 14, 2020 by Novârch

[Draco18s]

49 minutes ago, Alpvax said:

The isPresent() function seems virtually useless, what does it offer over doing .orElse(null), followed by a null check, because you cannot get the value without using orElse anyway?

ifPresent() takes a lambda operator. Anything that would go inside your if(val != null) block goes directly into that lambda.

[Alpvax]

2 hours ago, Novârch said:

LazyOptional.ifPresent(props -> {}) is what you want, props will be an instance of your capability. Here's an example of how I use it.

 

2 hours ago, Draco18s said:

ifPresent() takes a lambda operator. Anything that would go inside your if(val != null) block goes directly into that lambda.

Yes, I am aware of that method. But you cannot return a value from it. (scope is now lambda scope).

I was also asking about the isPresent method, not ifPresent.

[LexManos]

Its exactly as useful as the normal Java Optional.

isPresent replaces the null check if you just want to check if something is present.

It also doesn't call the resolve function so that's where the Lazy part comes in.

Your examples are also pretty bad. The way you would want to do it is like:
 

cap.map(e -> e.amount() * e.amountMultiplier()).orElse(0)

But ya the point is that LazyOptional gives you metadata about if it's present if all you care about is if it exists and delays the actual creation of the object you want until someone actually wants it.

 

[Alpvax]

19 hours ago, LexManos said:

Its exactly as useful as the normal Java Optional.

Except the normal optional also has the value() method public, saving the orElse call.

 

19 hours ago, LexManos said:

Your examples are also pretty bad. The way you would want to do it is like:
 

cap.map(e -> e.amount() * e.amountMultiplier()).orElse(0)

Yes, the example was in fact bad, and that was helpful, thank you. I didn't even thing of doing all the processing inside the Map function, I have always tried to make them as simple as possible.

[Draco18s]

53 minutes ago, Alpvax said:

Except the normal optional also has the value() method public, saving the orElse call.

Yes, that's why its called a lazy optional.

https://en.wikipedia.org/wiki/Lazy_initialization

[Alpvax]

Yes, but I'm about to use the value, so it will be calculated anyway.

 

Either way, the issue is solved, thanks.

[Draco18s]

11 minutes ago, Alpvax said:

Yes, but I'm about to use the value, so it will be calculated anyway.

But what if it doesn't HAVE a value? (This can happen if you attempt to get a capability on an object that doesn't have that capability). What do you want it to default to?

Do you want to do anything at all? Do you want to ignore it or throw an error?

 

Thus there are three possibilities:

ifPresent -> if a value exists, just do something

orElse -> get a value, or default value

orElesThrow -> get a value, or throw an error

 

val = orElse(null)
if(val != null) { /*code*/ }

 

is functionally equivalent to

 

ifPresent(val -> { /*code*/ } );

 

Edited May 15, 2020 by Draco18s

[Alpvax]

1 hour ago, Draco18s said:

But what if it doesn't HAVE a value?

But I know it does, because I just called isPresent. I would expect it to return null/throw an NPE (either would be acceptable).

 

1 hour ago, Draco18s said:

val = orElse(null)
if(val != null) { /*code*/ }

 

is functionally equivalent to

 

ifPresent(val -> { /*code*/ } );

Except that you cannot return anything from the second approach, which was the entire reasoning behind this query.

[Draco18s]

41 minutes ago, Alpvax said:

Except that you cannot return anything from the second approach

Why would you need to?

If isPresent is false, what value are you returning to your caller?

 

Sounds like a great use of orElse(default_value)

 

Or taking whatever your public int getAmount(ICapabilityProvider obj) { ... } method is and shoving that, in its entirety, into the place where it is being called and putting it inside an ifPresent.

 

The only valid use for isPresent is checking to see if the capability exists and doing something with only the information that it exists. You don't care what data is in it, only that it exists.

Edited May 15, 2020 by Draco18s

[Alpvax]

1 hour ago, Draco18s said:

Why would you need to?

Because many of the vanilla methods which I'm overriding have return values...

 

I'm dropping this thread now, Lex answered my question, and it seems you're never going to understand what I was attempting to achieve Draco.

[Draco18s]

8 minutes ago, Alpvax said:

Because many of the vanilla methods which I'm overriding have return values...

The code you posted did not make that clear.

 

8 minutes ago, Alpvax said:

Lex answered my question, and it seems you're never going to understand what I was attempting to achieve Draco.

He answered your question with a useage of orElse(0)

Which I have agreed with.

[Alpvax]

I have a follow up question:

I have a world capability, and one of the method returns is Optional (or could be @Nullable).

The LazyOptional#map argument is a NonNullFunction, and ideally I would return empty from the calling function rather than null.

 

//Capability.class
public Optional<INetworkNode> getNode(BlockPos pos) {
    return Optional.ofNullable(nodes.get(pos));
}

//Utility class (I'm happy to change the return type to LazyOptional)
public <T> Optional<T> ifNetworkNode(Function<INetworkNode, T> callback, BlockPos pos) {
    return getWorld().getCapability(Capabilities.NETWORK_CAPABILITY).map(graph ->
        graph.getNode(pos)
            .map(callback)
            .orElse(null) //<-- How can I unbox this Optional and return (Lazy)Optional.empty from the method instead of null?
        );
    );
}

 

Am I doing something wrong? Have I missed something obvious again?

 

EDIT: yes I was. I just needed to call orElseThrow on the LazyOptional

return getWorld().getCapability(Capabilities.NETWORK_GRAPH_CAPABILITY).map(graph ->
        graph.getNode(getPos()).map(callback)
    ).orElseThrow(() -> new NullPointerException("World %s did not have network capability attached"));

 

Edited May 19, 2020 by Alpvax
Answered my own query (missing something obvious again)