Performant functional evaluation for enum value
BigDecimal orderPrice = order.getSide().ifAsk(calcAskPrice(order)).ifBid(calcBidPrice(order)).elseFail();



This seems rather long and complicated.  Consider 

BigDecimal orderPrice = order.getSide().calculatePrice(order);


Or you might hide it as 

BigDecimal orderPrice = order.calculatePrice();


With 

BigDecimal calculatePrice() {
    return getSide().calculatePrice(this);
}


As you can read on Stack Overflow, you can then define different implementations of the method for each value of the enum.  

public enum Side {

    ASK {
        @Override
        public BigDecimal calculatePrice(Order order) {
            return Something.calcAskPrice(order);
        }
    },
    BID {
        @Override
        public BigDecimal calculatePrice(Order order) {
            return Something.calcBidPrice(order);
        }
    };


    public BigDecimal calculatePrice(Order order) {
        throw new IllegalArgumentException("The provided order must have a side that is either ASK or BID");
    }

}


I wrote Something, as you don't provide enough context to write whatever it actually is.  It's possible that the calcAskPrice and calcBidPrice methods should have their contents pulled into the override methods.  Or that you need to pass some kind of additional object to the calculatePrice methods.  

There's an argument that overriding a method like this is bad form.  I'll leave it up to you if that matters.  I did it here to duplicate your original functionality.  But maybe you don't need the original functionality.  Again, without more context, it's difficult to tell.  

Perhaps it should go without saying, but I didn't test this, as there isn't enough context.  I did not go the extra mile and verify syntactical correctness by dummying up a driver for this code.