Curries a function that takes four arguments.

@param function
the original function. May not be <code>null</code>.
@param argument
the fixed first argument of {@code function}.
@return a function that takes three arguments. Never <code>null</code>.
551643
@Pure
	public static <P1, P2, P3, P4, RESULT> Function3<P2, P3, P4, RESULT> curry(
			final Function4<? super P1, ? super P2, ? super P3, ? super P4, ? extends RESULT> function, final P1 argument) {
		if (function == null)
			throw new NullPointerException("function");
		return new Function3<P2, P3, P4, RESULT>() {
			@Override
			public RESULT apply(P2 p2, P3 p3, P4 p4) {
				return function.apply(argument, p2, p3, p4);
			}
		};
	}
588215
public <X extends Exception> void updateAll(Try.TriFunction<R, C, E, E, X> func) throws X {
        checkFrozen();

        if (rowLength() > 0 && columnLength() > 0) {
            this.init();

            final int rowLength = rowLength();
            int columnIndex = 0;
            C columnKey = null;

            for (List<E> column : _columnList) {
                columnKey = _columnKeyIndexMap.getByValue(columnIndex);

                for (int rowIndex = 0; rowIndex < rowLength; rowIndex++) {
                    column.set(rowIndex, func.apply(_rowKeyIndexMap.getByValue(rowIndex), columnKey, column.get(rowIndex)));
                }

                columnIndex++;
            }
        }
    }
32082
@Pure
	public static <P1, RESULT> Function0<RESULT> curry(final Function1<? super P1, ? extends RESULT> function, final P1 argument) {
		if (function == null)
			throw new NullPointerException("function");
		return new Function0<RESULT>() {
			@Override
			public RESULT apply() {
				return function.apply(argument);
			}
		};
	}
595398
function _curriedr (f, xs) {
    let t = typeOf(f);
    if (t === 'Function') {
        return f.length <= 1 ? f : arity(f.length - xs.length, (...ys) => {
            let a = [...xs, ...ys].filter(v => v !== void 0);
            if (a.length >= f.length) { return f(...a.reverse()); }
            return _curriedr(f, a);
        });
    }
    throw `curryRight :: Expected argument to be of type function but saw ${t}`;
}
1033509
function curry(fn, ...firstArgs) {
  return function(...secondArgs) {
    return fn.apply(null, firstArgs.concat(secondArgs));
  };
}
1082012
public static <T, R> Function1<T, R> memoizeFunction(final Function<T, R> fn) {
        final Map<T, R> lazy = new ConcurrentHashMap<>();
        LazyImmutable<R> nullR = LazyImmutable.def();
        return t -> t==null? nullR.computeIfAbsent(()->fn.apply(null)) : lazy.computeIfAbsent(t, fn);
    }
582420
@NonNull
  public static Term function(@NonNull CqlIdentifier functionId, @NonNull Term... arguments) {
    return function(functionId, Arrays.asList(arguments));
  }
914116
public void set(final Argument argument) {
        if (argument != null) {
            map.put(argument.getKey(), Collections.singleton(argument));
        }
    }
944403
public static <T, R, E extends Exception> Function<T, R> rethrowFunction(FunctionWithExceptions<T, R, E> function) throws E {
        return t -> {
            try {
                return function.apply(t);
            } catch (Exception exception) {
                throwAsUnchecked(exception);
                return null;
            }
        };
    }
981728
public static <T> Function<Void, T> wrap(final Function<T, T> function,
        final Function<Function<T, T>, T> wrapper) {
        return new Function<Void, T>() {
            public T apply(final Void arg) {
                return wrapper.apply(function);
            }
        };
    }
66629
@SuppressWarnings("unchecked")
    public static <T> Function<T, T> compose(final Function<T, T> ... func) {
        return new Function<T, T>() {
            public T apply(final T arg) {
                T result = arg;
                for (int index = func.length - 1; index >= 0; index -= 1) {
                    result = func[index].apply(result);
                }
                return result;
            }
        };
    }
729709
protected <S> S withFreshBuilder(Function<UriComponentsBuilder, S> function) {

		Assert.notNull(function, "Function must not be null!");

		return function.apply(builder.cloneBuilder());
	}
1355754
function curry(f) {
        var args = slice(arguments, 1);
        return function() { return f.apply(this, args.concat(slice(arguments))); };
}
59579
public <T> Optional<T> answer(Function<String, T> function) {
        return fromNullable(askBuilder.answer(function));
    }
752445
@Pure
	public static <P1, P2, RESULT> Function1<P2, RESULT> curry(final Function2<? super P1, ? super P2, ? extends RESULT> function,
			final P1 argument) {
		if (function == null)
			throw new NullPointerException("function");
		return new Function1<P2, RESULT>() {
			@Override
			public RESULT apply(P2 p) {
				return function.apply(argument, p);
			}
		};
	}
651859
@Pure
	public static <P1> Procedure0 curry(final Procedure1<? super P1> procedure, final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure0() {
			@Override
			public void apply() {
				procedure.apply(argument);
			}
		};
	}
291548
public boolean hasArgs(DifferentialFunction function) {
        List<String> vertexIdArgs = ops.get(function.getOwnName()).getInputsToOp();
        return vertexIdArgs != null && vertexIdArgs.size() > 0;
    }