openide/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/IDEA125254.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.BiFunction;

class Scratch
{
  public static void main(String[] args)
  {
    final ExecutorService threadPool = Executors.newCachedThreadPool();
    final List<EventObject> events = new ArrayList<>();
    final SoapInterface soap = new SoapInterface();

    events.stream()
      .map(event -> get(event).apply(soap, event))
      .map(threadPool::submit)
      .forEachOrdered(future -> {
        try
        {
          if (! future.get().isError())
          {

          }
          else
          {
            ;
          }
        }
        catch (InterruptedException | ExecutionException e)
        {
          e.printStackTrace();
        }
      });
  }

  public static BiFunction<SoapInterface, Object, Callable<Either<Object, Exception>>> get(Object o)
  {
    return (soap, event) -> toEither(
      () -> {
        return "value";
      }
    );
  }

  private static Callable<Either<Object, Exception>> toEither(Callable<Object> callable)
  {
    return () -> {
      try
      {
        return Either.value(callable.call());
      }
      catch (Exception e)
      {
        return Either.error(e);
      }
    };
  }

  public static class EventObject {  }

  public static class SoapInterface {  }

  public static class Either<V, E>
  {
    private V value;

    private E error;

    private Either(V value, E error)
    {
      this.value = value;
      this.error = error;
    }

    public static <V, E> Either<V, E> value(V value)
    {
      return new Either<>(value, null);
    }

    public static <V, E> Either<V, E> error(E error)
    {
      return new Either<>(null, error);
    }

    public V getValue()
    {
      return value;
    }

    public E getError()
    {
      return error;
    }

    public boolean isError()
    {
      return error != null;
    }
  }
}