Lift a Java Func0 to a Scala Function0

@param f the function to lift

@returns the Scala function
976918
public static<Z> Function0<Z> lift(Func0<Z> f) {
	return bridge.lift(f);
    }
906574
public static <F1, T1, F2, T2, KeyT extends F1, TestT extends F2>
  Function<EvalPair<? extends KeyT, ? extends TestT>, EvalPair<T1, T2>> functionsOnBoth(
      final Function<F1, T1> keyFunc, final Function<F2,T2> testFunc) {
    return new Function<EvalPair<? extends KeyT, ? extends TestT>, EvalPair<T1, T2>>() {
      @Override
      public EvalPair<T1, T2> apply(final EvalPair<? extends KeyT, ? extends TestT> input) {
        return EvalPair.of(keyFunc.apply(input.key()), testFunc.apply(input.test()));
      }

      @Override
      public String toString() {
        return "EvalPair.functionsOnBoth(" + keyFunc + ", " + testFunc + ")";
      }
    };
  }
491084
@NonNull
  public static Drop dropFunction(@NonNull String functionName) {
    return new DefaultDrop(CqlIdentifier.fromCql(functionName), "FUNCTION");
  }
728901
@MapMethod
    public Map<String,Object> iterate(Map<String,Object> o, final ScriptFunction f){
        return Objects.iterate(o,new Closure<ObjectIterator.IterateBean, Object>() {
            @Override
            public Object call(ObjectIterator.IterateBean input) {
                return f.call(Objects.newHashMap(String.class,Object.class,
                        "path",input.getPath(),
                        "value",input.getValue(),
                        "name",input.getName()
                        ));
            }
        });
    }
587208
public static <K, V> Function<K, V> asFunction(Map<K, ? extends V> map,
      Function<K, ? extends V> defaultFunction) {
    return new ForMapWithDefaultFunction<K, V>(map, defaultFunction);
  }
1325089
public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7, T8, Void> toFunc(
            final Action8<T1, T2, T3, T4, T5, T6, T7, T8> action) {
        return toFunc(action, (Void) null);
    }
144117
public static Key make(File f) {
    Futures fs = new Futures();
    Key key = make(f, fs);
    fs.blockForPending();
    return key;
  }
942518
public static Symm obtain(File f) throws IOException {
	  FileInputStream fis = new FileInputStream(f);
	  try {
		  return obtain(fis);
	  } finally {
		  fis.close();
	  }
  }
576380
public static <T> TypedColumn<T, Double> sum(MapFunction<T, Double> f) {
    return new TypedSumDouble<T>(f).toColumnJava();
  }
1080991
@SequentialOnly
    public static <T> Function<T, Indexed<T>> indexed() {
        return new Function<T, Indexed<T>>() {
            private final MutableLong idx = new MutableLong(0);

            @Override
            public Indexed<T> apply(T t) {
                return Indexed.of(t, idx.getAndIncrement());
            }
        };
    }
201282
public <R, F extends ThirdFunction<R, Integer, Integer, List<Sort>>> R get(F thirdFunction) {
        if (StringUtils.isBlank(sort)) {
            return thirdFunction.apply(PageUtils.page(page), PageUtils.size(size), Lists.newArrayList());
        }
        List<Sort> sorts = Arrays.stream(sort.split(",")).map(s -> {
            try {
                String[] split = s.split("-");
                if (split.length == 1) {
                    return new Sort(this.apply(split[0]), DESC);
                }
                String direction = split[1];
                direction = !DESC.equalsIgnoreCase(direction) && !ASC.equalsIgnoreCase(direction) ? DESC : direction;
                return new Sort(this.apply(split[0]), direction);
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return null;
            }
        }).collect(Collectors.toList());
        return thirdFunction.apply(PageUtils.page(page), PageUtils.size(size), sorts);
    }
1031335
public <A> Optional<A> transform(final ThrowableFunction<Payload, A, IOException> f) {
        if (hasPayload()) {
            return payload.flatMap(p -> lift(p, f));
        }
        return Optional.empty();
    }
934361
public static <R, C, V> Function<Table.Cell<R, C, V>, C> toColumnKeyFunction() {
    return new Function<Table.Cell<R, C, V>, C>() {
      @Override
      public C apply(final Table.Cell<R, C, V> input) {
        return input.getColumnKey();
      }
    };
  }
552229
@Override
    public <B> ListT<W,B> map(final Function<? super T, ? extends B> f) {
        return of(run.map(o -> o.map(f)));
    }
905396
public static <T> TypedColumn<T, Double> avg(MapFunction<T, Double> f) {
    return new TypedAverage<T>(f).toColumnJava();
  }
373129
public static float nextUpF(float f) {
        if (Float.isNaN(f) || f == Float.POSITIVE_INFINITY) {
            return f;
        } else {
            f += 0.0f;
            return Float.intBitsToFloat(Float.floatToRawIntBits(f) + ((f >= 0.0f) ? +1 : -1));
        }
    }
137947
public Try<T, X> recoverFlatMap(Function<? super X, ? extends Try<T, X>> fn){
        return new Try<>(xor.flatMapLeftToRight(fn.andThen(t->t.xor)),classes);
    }