Package com.github.underscore

Class $<T>

java.lang.Object

com.github.underscore.$<T>

Direct Known Subclasses:

$

public class $<T>
extends Object

Underscore-java is a java port of Underscore.js.

Author:

Valentyn Kolesnikov

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	$.Chain<T>

Constructor Summary

Constructors

Constructor	Description
$(Iterable<T> iterable)
$(String string)

Method Summary

Modifier and Type	Method	Description
static <E> Supplier<E>	after(int count, Supplier<E> function)
static <E> boolean	all(Iterable<E> iterable, Predicate<E> pred)
boolean	all(Predicate<T> pred)
static <E> boolean	any(Iterable<E> iterable, Predicate<E> pred)
boolean	any(Predicate<T> pred)
static <E> Supplier<E>	before(int count, Supplier<E> function)
static <T,F> Function<F,T>	bind(Function<F,T> function)
Optional<String>	call(String funcName)
$.Chain<T>	chain()
static $.Chain<Integer>	chain(int[] array)
static <T> $.Chain<T>	chain(Iterable<T> iterable)
static <T> $.Chain<T>	chain(Iterable<T> iterable, int size)
static <T> $.Chain<T>	chain(List<T> list)
static <T> $.Chain<T>	chain(T... array)
static <T> T	checkNotNull(T reference)
static <T> T	checkNotNull(T reference, Object errorMessage)
List<List<T>>	chunk(int size)
static <T> List<List<T>>	chunk(Iterable<T> iterable, int size)
static void	clearInterval(ScheduledFuture scheduledFuture)
static void	clearTimeout(ScheduledFuture scheduledFuture)
static <E> E[]	clone(E... iterable)
static Object	clone(Object obj)
static <T,E> List<T>	collect(List<E> list, Function<? super E,T> func)
static <T,E> Set<T>	collect(Set<E> set, Function<? super E,T> func)
List<T>	compact()
static <E> E[]	compact(E... array)
static <E> E[]	compact(E[] array, E falsyValue)
static <E> List<E>	compact(List<E> list)
static <E> List<E>	compact(List<E> list, E falsyValue)
List<T>	compact(T falsyValue)
static <T> Function<T,T>	compose(Function<T,T>... func)
static <T> List<T>	concat(Iterable<T> first, Iterable<T>... other)
static <T> T[]	concat(T[] first, T[]... other)
List<T>	concatWith(Iterable<T>... other)
static <E> Supplier<E>	constant(E value)
static <E> boolean	contains(Iterable<E> iterable, E elem)
static <E> boolean	contains(Iterable<E> iterable, E elem, int fromIndex)
boolean	contains(T elem)
List<T>	copyOf()
static <T> List<T>	copyOf(Iterable<T> iterable)
List<T>	copyOfRange(int start, int end)
static <T> List<T>	copyOfRange(Iterable<T> iterable, int start, int end)
static <K,E> Map<K,Integer>	countBy(Iterable<E> iterable, Function<E,K> func)
<K,E> Map<K,Integer>	countBy(Function<E,K> func)
static <T> Supplier<T>	debounce(Supplier<T> function, int delayMilliseconds)
static <K,V> Map<K,V>	defaults(Map<K,V> object, Map<K,V> defaults)
static <T> ScheduledFuture<T>	defer(Supplier<T> function)
static <T> ScheduledFuture<T>	delay(Supplier<T> function, int delayMilliseconds)
static <E> Optional<E>	detect(Iterable<E> iterable, Predicate<E> pred)
static <E> E[]	difference(E[]... arrays)
static <E> List<E>	difference(List<E> list1, List<E> list2)
static <E> List<E>	difference(List<E> list, List<E>... lists)
List<T>	differenceWith(List<T>... lists)
static <E> E[]	distinct(E... array)
static <E> List<E>	distinct(List<E> list)
static <K,E> E[]	distinctBy(E[] array, Function<E,K> func)
static <K,E> Collection<E>	distinctBy(Iterable<E> iterable, Function<E,K> func)
static <E> E[]	drop(E... array)
static <E> E[]	drop(E[] array, int n)
static <E> List<E>	drop(List<E> list)
static <E> List<E>	drop(List<E> list, int n)
static <T> void	each(Iterable<T> iterable, Consumer<? super T> func)
void	each(Consumer<? super T> func)
static <T> void	eachRight(Iterable<T> iterable, Consumer<? super T> func)
void	eachRight(Consumer<? super T> func)
T	elementAt(int index)
static <T> T	elementAt(List<T> list, int index)
T	elementAtOrElse(int index, T defaultValue)
static <T> T	elementAtOrElse(List<T> list, int index, T defaultValue)
T	elementAtOrNull(int index)
static <T> T	elementAtOrNull(List<T> list, int index)
static String	escape(String value)
static <E> boolean	every(Iterable<E> iterable, Predicate<E> pred)
boolean	every(Predicate<T> pred)
static <K,V> Map<K,V>	extend(Map<K,V> destination, Map<K,V>... sources)
List<T>	filter(Predicate<T> pred)
static <E> List<E>	filter(List<E> list, Predicate<E> pred)
static <E> Set<E>	filter(Set<E> set, Predicate<E> pred)
List<T>	filterFalse(Predicate<T> pred)
static <E> List<E>	filterFalse(List<E> list, Predicate<E> pred)
static <E> Set<E>	filterFalse(Set<E> set, Predicate<E> pred)
static <E> List<E>	filterIndexed(List<E> list, PredicateIndexed<E> pred)
static <E> Optional<E>	find(Iterable<E> iterable, Predicate<E> pred)
static <E> int	findIndex(E[] array, Predicate<E> pred)
static <E> int	findIndex(List<E> list, Predicate<E> pred)
static <E> E	findKey(E[] array, Predicate<E> pred)
static <E> E	findKey(List<E> list, Predicate<E> pred)
static <E> Optional<E>	findLast(Iterable<E> iterable, Predicate<E> pred)
static <E> int	findLastIndex(E[] array, Predicate<E> pred)
static <E> int	findLastIndex(List<E> list, Predicate<E> pred)
static <E> E	findLastKey(E[] array, Predicate<E> pred)
static <E> E	findLastKey(List<E> list, Predicate<E> pred)
static <T,E> Optional<E>	findWhere(Iterable<E> iterable, List<Tuple<String,T>> properties)
<E> Optional<T>	findWhere(List<Tuple<String,E>> properties)
T	first()
List<T>	first(int n)
static <E> E	first(E... array)
static <E> E	first(Iterable<E> iterable)
static <E> E	first(Iterable<E> iterable, Predicate<E> pred)
T	first(Predicate<T> pred)
static <E> List<E>	first(List<E> list, int n)
T	firstOrNull()
static <E> E	firstOrNull(Iterable<E> iterable)
static <E> E	firstOrNull(Iterable<E> iterable, Predicate<E> pred)
T	firstOrNull(Predicate<T> pred)
List<T>	flatten()
List<T>	flatten(boolean shallow)
static <E> List<E>	flatten(List<?> list)
static <E> List<E>	flatten(List<?> list, boolean shallow)
static <T,E> E	foldl(Iterable<T> iterable, FunctionAccum<E,T> func, E zeroElem)
static <T,E> E	foldr(Iterable<T> iterable, FunctionAccum<E,T> func, E zeroElem)
static <T> void	forEach(Iterable<T> iterable, Consumer<? super T> func)
void	forEach(Consumer<? super T> func)
static <T> void	forEachRight(Iterable<T> iterable, Consumer<? super T> func)
void	forEachRight(Consumer<? super T> func)
static String	format(String template, Object... params)
static List<String>	functions(Object object)
T	get(int index)
static <T> T	get(List<T> list, int index)
Iterable<T>	getIterable()
Optional<String>	getString()
static <K,E> Map<K,List<E>>	groupBy(Iterable<E> iterable, Function<E,K> func)
<K,E> Map<K,List<E>>	groupBy(Function<E,K> func)
static <K,V> boolean	has(Map<K,V> object, K key)
T	head()
List<T>	head(int n)
static <E> E	head(E... array)
static <E> E	head(Iterable<E> iterable)
static <E> List<E>	head(List<E> list, int n)
static <E> E	identity(E value)
static <E> boolean	include(Iterable<E> iterable, E elem)
static <K,E> Map<K,List<E>>	indexBy(Iterable<E> iterable, String property)
<K,E> Map<K,List<E>>	indexBy(String property)
static <E> int	indexOf(E[] array, E value)
static <E> int	indexOf(List<E> list, E value)
List<T>	initial()
List<T>	initial(int n)
static <E> E[]	initial(E... array)
static <E> E[]	initial(E[] array, int n)
static <E> List<E>	initial(List<E> list)
static <E> List<E>	initial(List<E> list, int n)
static <T,E> E	inject(Iterable<T> iterable, FunctionAccum<E,T> func, E zeroElem)
static <E> E[]	intersection(E[]... arrays)
static <E> List<E>	intersection(List<E> list1, List<E> list2)
static <E> List<E>	intersection(List<E> list, List<E>... lists)
List<T>	intersectionWith(List<T>... lists)
static <K,V> List<Tuple<V,K>>	invert(Map<K,V> object)
static <E> List<E>	invoke(Iterable<E> iterable, String methodName)
static <E> List<E>	invoke(Iterable<E> iterable, String methodName, List<Object> args)
List<T>	invoke(String methodName)
List<T>	invoke(String methodName, List<Object> args)
static boolean	isArray(Object object)
static boolean	isBoolean(Object object)
static boolean	isDate(Object object)
boolean	isEmpty()
static <T> boolean	isEmpty(Iterable<T> iterable)
static <K,V> boolean	isEmpty(Map<K,V> object)
static boolean	isEqual(Object object, Object other)
static boolean	isError(Object object)
static boolean	isFunction(Object object)
static <K,V> boolean	isMatch(Map<K,V> object, Map<K,V> properties)
static boolean	isNull(Object object)
static boolean	isNumber(Object object)
static boolean	isObject(Object object)
static boolean	isRegExp(Object object)
static boolean	isString(Object object)
static <T> Iterable<T>	iterate(T seed, UnaryOperator<T> unaryOperator)
static <K,V> Function<Map<K,V>,V>	iteratee(K key)
String	join()
static <T> String	join(Iterable<T> iterable)
static <T> String	join(Iterable<T> iterable, String separator)
String	join(String separator)
static <T> String	join(T[] array)
static <T> String	join(T[] array, String separator)
static <K,V> Set<K>	keys(Map<K,V> object)
T	last()
List<T>	last(int n)
static <E> E	last(E... array)
T	last(Predicate<T> pred)
static <E> E	last(List<E> list)
static <E> List<E>	last(List<E> list, int n)
static <E> E	last(List<E> list, Predicate<E> pred)
static int	lastIndex(int[] array)
static <T> int	lastIndex(Iterable<T> iterable)
static <T> int	lastIndex(T[] array)
static <E> int	lastIndexOf(E[] array, E value)
static <E> int	lastIndexOf(List<E> list, E value)
T	lastOrNull()
T	lastOrNull(Predicate<T> pred)
static <E> E	lastOrNull(List<E> list)
static <E> E	lastOrNull(List<E> list, Predicate<E> pred)
static void	main(String... args)
static <T> List<T>	map(int[] array, Function<? super Integer,T> func)
<F> List<F>	map(Function<? super T,F> func)
static <T,E> List<T>	map(List<E> list, Function<? super E,T> func)
static <T,E> Set<T>	map(Set<E> set, Function<? super E,T> func)
static <K,V> List<Tuple<K,V>>	mapObject(Map<K,V> object, Function<? super V,V> func)
static <K,V> Predicate<Map<K,V>>	matcher(Map<K,V> object)
T	max()
static <E extends Comparable<? super E>> E	max(Collection<E> collection)
static <E,F extends Comparable> E	max(Collection<E> collection, Function<E,F> func)
<F extends Comparable<? super F>> T	max(Function<T,F> func)
static <T,F> Function<F,T>	memoize(Function<F,T> function)
static List<String>	methods(Object object)
T	min()
static <E extends Comparable<? super E>> E	min(Collection<E> collection)
static <E,F extends Comparable> E	min(Collection<E> collection, Function<E,F> func)
<F extends Comparable<? super F>> T	min(Function<T,F> func)
static void	mixin(String funcName, Function<String,String> func)
static <E> Predicate<E>	negate(Predicate<E> pred)
protected static <T> List<T>	newArrayList()
protected static <T> List<T>	newArrayList(Iterable<T> iterable)
protected static <T> List<T>	newArrayList(Iterable<T> iterable, int size)
protected static <T> List<T>	newArrayListWithExpectedSize(int size)
protected static List<Integer>	newIntegerList(int... array)
protected static <K,E> Map<K,E>	newLinkedHashMap()
protected static <T> Set<T>	newLinkedHashSet()
protected static <T> Set<T>	newLinkedHashSet(Iterable<T> iterable)
protected static <T> Set<T>	newLinkedHashSetWithExpectedSize(int size)
static long	now()
static <K,V> List<Tuple<K,V>>	object(List<K> keys, List<V> values)
static <K,V> List<Tuple<K,V>>	omit(Map<K,V> object, Predicate<V> pred)
static <K,V> List<Tuple<K,V>>	omit(Map<K,V> object, V... keys)
static <T> Supplier<T>	once(Supplier<T> function)
static <K,V> List<Tuple<K,V>>	pairs(Map<K,V> object)
static <E> List<E>[]	partition(E[] iterable, Predicate<E> pred)
static <E> List<List<E>>	partition(Iterable<E> iterable, Predicate<E> pred)
static <K,V> List<Tuple<K,V>>	pick(Map<K,V> object, Predicate<V> pred)
static <K,V> List<Tuple<K,V>>	pick(Map<K,V> object, V... keys)
List<Object>	pluck(String propertyName)
static <E> List<Object>	pluck(List<E> list, String propertyName)
static <E> Set<Object>	pluck(Set<E> set, String propertyName)
Tuple<T,List<T>>	pop()
static <T> Tuple<T,List<T>>	pop(List<T> list)
static <K,V> Function<Map<K,V>,V>	property(K key)
static <K,V> Function<K,V>	propertyOf(Map<K,V> object)
static <T> List<T>	push(List<T> list, T... values)
List<T>	push(T... values)
static int	random(int max)
static int	random(int min, int max)
static int[]	range(int stop)
static int[]	range(int start, int stop)
static int[]	range(int start, int stop, int step)
static <E> E	reduce(int[] array, FunctionAccum<E,? super Integer> func, E zeroElem)
static <T,E> E	reduce(Iterable<T> iterable, FunctionAccum<E,T> func, E zeroElem)
static <T,E> E	reduce(T[] array, FunctionAccum<E,T> func, E zeroElem)
static <E> E	reduceRight(int[] array, FunctionAccum<E,? super Integer> func, E zeroElem)
static <T,E> E	reduceRight(Iterable<T> iterable, FunctionAccum<E,T> func, E zeroElem)
static <T,E> E	reduceRight(T[] array, FunctionAccum<E,T> func, E zeroElem)
List<T>	reject(Predicate<T> pred)
static <E> List<E>	reject(List<E> list, Predicate<E> pred)
static <E> Set<E>	reject(Set<E> set, Predicate<E> pred)
static <E> List<E>	rejectIndexed(List<E> list, PredicateIndexed<E> pred)
List<T>	rest()
List<T>	rest(int n)
static <E> E[]	rest(E... array)
static <E> E[]	rest(E[] array, int n)
static <E> List<E>	rest(List<E> list)
static <E> List<E>	rest(List<E> list, int n)
static <E> Object	result(Iterable<E> iterable, Predicate<E> pred)
List<T>	reverse()
static List<Integer>	reverse(int[] array)
static <T> List<T>	reverse(Iterable<T> iterable)
static <T> T[]	reverse(T... array)
T	sample()
static <E> E	sample(Iterable<E> iterable)
static <E> Set<E>	sample(List<E> list, int howMany)
static <E> List<E>	select(List<E> list, Predicate<E> pred)
static <E> Set<E>	select(Set<E> set, Predicate<E> pred)
Tuple<T,List<T>>	set(int index, T value)
static <T> Tuple<T,List<T>>	set(List<T> list, int index, T value)
static <T> ScheduledFuture	setInterval(Supplier<T> function, int delayMilliseconds)
static <T> ScheduledFuture<T>	setTimeout(Supplier<T> function, int delayMilliseconds)
Tuple<T,List<T>>	shift()
static <T> Tuple<T,List<T>>	shift(List<T> list)
List<T>	shuffle()
static <E> List<E>	shuffle(Iterable<E> iterable)
int	size()
static <E> int	size(E... array)
static int	size(Iterable<?> iterable)
List<T>	slice(int start)
List<T>	slice(int start, int end)
static <T> List<T>	slice(Iterable<T> iterable, int start)
static <T> List<T>	slice(Iterable<T> iterable, int start, int end)
static <T> T[]	slice(T[] array, int start)
static <T> T[]	slice(T[] array, int start, int end)
static <E> boolean	some(Iterable<E> iterable, Predicate<E> pred)
boolean	some(Predicate<T> pred)
List<Comparable>	sort()
static <T extends Comparable<T>> List<T>	sort(Iterable<T> iterable)
static <T extends Comparable<T>> T[]	sort(T... array)
static <E,T extends Comparable<? super T>> List<E>	sortBy(Iterable<E> iterable, Function<E,T> func)
static <K,V extends Comparable<? super V>> List<Map<K,V>>	sortBy(Iterable<Map<K,V>> iterable, K key)
<E,V extends Comparable<? super V>> List<E>	sortBy(Function<E,V> func)
static <E extends Comparable<E>> int	sortedIndex(E[] array, E value)
static <E extends Comparable<E>> int	sortedIndex(E[] array, E value, String propertyName)
static <E extends Comparable<E>> int	sortedIndex(List<E> list, E value)
static <E extends Comparable<E>> int	sortedIndex(List<E> list, E value, String propertyName)
static <T extends Comparable<? super T>> List<T>	sortWith(Iterable<T> iterable, Comparator<T> comparator)
<T extends Comparable<? super T>> List<T>	sortWith(Comparator<T> comparator)
List<T>	tail()
List<T>	tail(int n)
static <E> E[]	tail(E... array)
static <E> E[]	tail(E[] array, int n)
static <E> List<E>	tail(List<E> list)
static <E> List<E>	tail(List<E> list, int n)
static <T> void	tap(Iterable<T> iterable, Consumer<? super T> func)
static <K,V> Template<Map<K,V>>	template(String template)
static void	templateSettings(Map<String,String> templateSettings)
static <T> Supplier<T>	throttle(Supplier<T> function, int waitMilliseconds)
static <E> void	times(int count, Supplier<E> function)
<E> E[]	toArray()
static <E> E[]	toArray(Iterable<E> iterable)
<K,V> Map<K,V>	toMap()
static <K,V> Map<K,V>	toMap(Iterable<Map.Entry<K,V>> iterable)
static <K,V> Map<K,V>	toMap(List<Tuple<K,V>> tuples)
static String	unescape(String value)
static <E> E[]	union(E[]... arrays)
static <E> List<E>	union(List<E> list, List<E>... lists)
List<T>	unionWith(List<T>... lists)
static <E> E[]	uniq(E... array)
static <K,E> E[]	uniq(E[] array, Function<E,K> func)
static <K,E> Collection<E>	uniq(Iterable<E> iterable, Function<E,K> func)
static <E> List<E>	uniq(List<E> list)
static String	uniqueId(String prefix)
static String	uniquePassword()
static <T> List<T>	unshift(List<T> list, T... values)
List<T>	unshift(T... values)
static <T> List<List<T>>	unzip(List<T>... lists)
Iterable<T>	value()
static <K,V> Collection<V>	values(Map<K,V> object)
<E> List<T>	where(List<Tuple<String,E>> properties)
static <T,E> List<E>	where(List<E> list, List<Tuple<String,T>> properties)
static <T,E> Set<E>	where(Set<E> set, List<Tuple<String,T>> properties)
static <E> E[]	without(E[] array, E... values)
static <E> List<E>	without(List<E> list, E... values)
static <T> Function<Void,T>	wrap(Function<T,T> function, Function<Function<T,T>,T> wrapper)
static <T> List<List<T>>	zip(List<T>... lists)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

$

public $(Iterable<T> iterable)

$

public $(String string)

Method Detail

templateSettings

public static void templateSettings(Map<String,String> templateSettings)

iteratee

public static <K,V> Function<Map<K,V>,V> iteratee(K key)

each

public static <T> void each(Iterable<T> iterable,
                            Consumer<? super T> func)

each

public void each(Consumer<? super T> func)

eachRight

public static <T> void eachRight(Iterable<T> iterable,
                                 Consumer<? super T> func)

eachRight

public void eachRight(Consumer<? super T> func)

forEach

public static <T> void forEach(Iterable<T> iterable,
                               Consumer<? super T> func)

forEach

public void forEach(Consumer<? super T> func)

forEachRight

public static <T> void forEachRight(Iterable<T> iterable,
                                    Consumer<? super T> func)

forEachRight

public void forEachRight(Consumer<? super T> func)

map

public static <T,E> List<T> map(List<E> list,
                                Function<? super E,T> func)

map

public <F> List<F> map(Function<? super T,F> func)

map

public static <T> List<T> map(int[] array,
                              Function<? super Integer,T> func)

map

public static <T,E> Set<T> map(Set<E> set,
                               Function<? super E,T> func)

collect

public static <T,E> List<T> collect(List<E> list,
                                    Function<? super E,T> func)

collect

public static <T,E> Set<T> collect(Set<E> set,
                                   Function<? super E,T> func)

reduce

public static <T,E> E reduce(Iterable<T> iterable,
                             FunctionAccum<E,T> func,
                             E zeroElem)

reduce

public static <E> E reduce(int[] array,
                           FunctionAccum<E,? super Integer> func,
                           E zeroElem)

reduce

public static <T,E> E reduce(T[] array,
                             FunctionAccum<E,T> func,
                             E zeroElem)

foldl

public static <T,E> E foldl(Iterable<T> iterable,
                            FunctionAccum<E,T> func,
                            E zeroElem)

inject

public static <T,E> E inject(Iterable<T> iterable,
                             FunctionAccum<E,T> func,
                             E zeroElem)

reduceRight

public static <T,E> E reduceRight(Iterable<T> iterable,
                                  FunctionAccum<E,T> func,
                                  E zeroElem)

reduceRight

public static <E> E reduceRight(int[] array,
                                FunctionAccum<E,? super Integer> func,
                                E zeroElem)

reduceRight

public static <T,E> E reduceRight(T[] array,
                                  FunctionAccum<E,T> func,
                                  E zeroElem)

foldr

public static <T,E> E foldr(Iterable<T> iterable,
                            FunctionAccum<E,T> func,
                            E zeroElem)

find

public static <E> Optional<E> find(Iterable<E> iterable,
                                   Predicate<E> pred)

detect

public static <E> Optional<E> detect(Iterable<E> iterable,
                                     Predicate<E> pred)

findLast

public static <E> Optional<E> findLast(Iterable<E> iterable,
                                       Predicate<E> pred)

filter

public static <E> List<E> filter(List<E> list,
                                 Predicate<E> pred)

filter

public List<T> filter(Predicate<T> pred)

filterIndexed

public static <E> List<E> filterIndexed(List<E> list,
                                        PredicateIndexed<E> pred)

filter

public static <E> Set<E> filter(Set<E> set,
                                Predicate<E> pred)

select

public static <E> List<E> select(List<E> list,
                                 Predicate<E> pred)

select

public static <E> Set<E> select(Set<E> set,
                                Predicate<E> pred)

reject

public static <E> List<E> reject(List<E> list,
                                 Predicate<E> pred)

reject

public List<T> reject(Predicate<T> pred)

rejectIndexed

public static <E> List<E> rejectIndexed(List<E> list,
                                        PredicateIndexed<E> pred)

reject

public static <E> Set<E> reject(Set<E> set,
                                Predicate<E> pred)

filterFalse

public static <E> List<E> filterFalse(List<E> list,
                                      Predicate<E> pred)

filterFalse

public List<T> filterFalse(Predicate<T> pred)

filterFalse

public static <E> Set<E> filterFalse(Set<E> set,
                                     Predicate<E> pred)

every

public static <E> boolean every(Iterable<E> iterable,
                                Predicate<E> pred)

every

public boolean every(Predicate<T> pred)

all

public static <E> boolean all(Iterable<E> iterable,
                              Predicate<E> pred)

all

public boolean all(Predicate<T> pred)

some

public static <E> boolean some(Iterable<E> iterable,
                               Predicate<E> pred)

some

public boolean some(Predicate<T> pred)

any

public static <E> boolean any(Iterable<E> iterable,
                              Predicate<E> pred)

any

public boolean any(Predicate<T> pred)

contains

public static <E> boolean contains(Iterable<E> iterable,
                                   E elem)

contains

public boolean contains(T elem)

contains

public static <E> boolean contains(Iterable<E> iterable,
                                   E elem,
                                   int fromIndex)

include

public static <E> boolean include(Iterable<E> iterable,
                                  E elem)

invoke

public static <E> List<E> invoke(Iterable<E> iterable,
                                 String methodName,
                                 List<Object> args)

invoke

public List<T> invoke(String methodName,
                      List<Object> args)

invoke

public static <E> List<E> invoke(Iterable<E> iterable,
                                 String methodName)

invoke

public List<T> invoke(String methodName)

pluck

public static <E> List<Object> pluck(List<E> list,
                                     String propertyName)

pluck

public List<Object> pluck(String propertyName)

pluck

public static <E> Set<Object> pluck(Set<E> set,
                                    String propertyName)

where

public static <T,E> List<E> where(List<E> list,
                                  List<Tuple<String,T>> properties)

where

public <E> List<T> where(List<Tuple<String,E>> properties)

where

public static <T,E> Set<E> where(Set<E> set,
                                 List<Tuple<String,T>> properties)

findWhere

public static <T,E> Optional<E> findWhere(Iterable<E> iterable,
                                          List<Tuple<String,T>> properties)

findWhere

public <E> Optional<T> findWhere(List<Tuple<String,E>> properties)

max

public static <E extends Comparable<? super E>> E max(Collection<E> collection)

max

public T max()

max

public static <E,F extends Comparable> E max(Collection<E> collection,
                                             Function<E,F> func)

max

public <F extends Comparable<? super F>> T max(Function<T,F> func)

min

public static <E extends Comparable<? super E>> E min(Collection<E> collection)

min

public T min()

min

public static <E,F extends Comparable> E min(Collection<E> collection,
                                             Function<E,F> func)

min

public <F extends Comparable<? super F>> T min(Function<T,F> func)

shuffle

public static <E> List<E> shuffle(Iterable<E> iterable)

shuffle

public List<T> shuffle()

sample

public static <E> E sample(Iterable<E> iterable)

sample

public T sample()

sample

public static <E> Set<E> sample(List<E> list,
                                int howMany)

sortWith

public static <T extends Comparable<? super T>> List<T> sortWith(Iterable<T> iterable,
                                                                 Comparator<T> comparator)

sortWith

public <T extends Comparable<? super T>> List<T> sortWith(Comparator<T> comparator)

sortBy

public static <E,T extends Comparable<? super T>> List<E> sortBy(Iterable<E> iterable,
                                                                 Function<E,T> func)

sortBy

public <E,V extends Comparable<? super V>> List<E> sortBy(Function<E,V> func)

sortBy

public static <K,V extends Comparable<? super V>> List<Map<K,V>> sortBy(Iterable<Map<K,V>> iterable,
                                                                        K key)

groupBy

public static <K,E> Map<K,List<E>> groupBy(Iterable<E> iterable,
                                           Function<E,K> func)

groupBy

public <K,E> Map<K,List<E>> groupBy(Function<E,K> func)

indexBy

public static <K,E> Map<K,List<E>> indexBy(Iterable<E> iterable,
                                           String property)

indexBy

public <K,E> Map<K,List<E>> indexBy(String property)

countBy

public static <K,E> Map<K,Integer> countBy(Iterable<E> iterable,
                                           Function<E,K> func)

countBy

public <K,E> Map<K,Integer> countBy(Function<E,K> func)

toArray

public static <E> E[] toArray(Iterable<E> iterable)

toArray

public <E> E[] toArray()

toMap

public static <K,V> Map<K,V> toMap(Iterable<Map.Entry<K,V>> iterable)

toMap

public <K,V> Map<K,V> toMap()

toMap

public static <K,V> Map<K,V> toMap(List<Tuple<K,V>> tuples)

size

public static int size(Iterable<?> iterable)

size

public int size()

size

public static <E> int size(E... array)

partition

public static <E> List<List<E>> partition(Iterable<E> iterable,
                                          Predicate<E> pred)

partition

public static <E> List<E>[] partition(E[] iterable,
                                      Predicate<E> pred)

first

public static <E> E first(Iterable<E> iterable)

first

public static <E> E first(E... array)

first

public static <E> List<E> first(List<E> list,
                                int n)

first

public T first()

first

public List<T> first(int n)

first

public static <E> E first(Iterable<E> iterable,
                          Predicate<E> pred)

first

public T first(Predicate<T> pred)

firstOrNull

public static <E> E firstOrNull(Iterable<E> iterable)

firstOrNull

public T firstOrNull()

firstOrNull

public static <E> E firstOrNull(Iterable<E> iterable,
                                Predicate<E> pred)

firstOrNull

public T firstOrNull(Predicate<T> pred)

head

public static <E> E head(Iterable<E> iterable)

head

@SafeVarargs
public static <E> E head(E... array)

head

public static <E> List<E> head(List<E> list,
                               int n)

head

public T head()

head

public List<T> head(int n)

initial

public static <E> List<E> initial(List<E> list)

initial

public static <E> List<E> initial(List<E> list,
                                  int n)

initial

public static <E> E[] initial(E... array)

initial

public static <E> E[] initial(E[] array,
                              int n)

initial

public List<T> initial()

initial

public List<T> initial(int n)

last

@SafeVarargs
public static <E> E last(E... array)

last

public static <E> E last(List<E> list)

last

public static <E> List<E> last(List<E> list,
                               int n)

last

public T last()

last

public List<T> last(int n)

last

public static <E> E last(List<E> list,
                         Predicate<E> pred)

last

public T last(Predicate<T> pred)

lastOrNull

public static <E> E lastOrNull(List<E> list)

lastOrNull

public T lastOrNull()

lastOrNull

public static <E> E lastOrNull(List<E> list,
                               Predicate<E> pred)

lastOrNull

public T lastOrNull(Predicate<T> pred)

rest

public static <E> List<E> rest(List<E> list)

rest

public static <E> List<E> rest(List<E> list,
                               int n)

rest

public static <E> E[] rest(E... array)

rest

public static <E> E[] rest(E[] array,
                           int n)

rest

public List<T> rest()

rest

public List<T> rest(int n)

tail

public static <E> List<E> tail(List<E> list)

tail

public static <E> List<E> tail(List<E> list,
                               int n)

tail

@SafeVarargs
public static <E> E[] tail(E... array)

tail

public static <E> E[] tail(E[] array,
                           int n)

tail

public List<T> tail()

tail

public List<T> tail(int n)

drop

public static <E> List<E> drop(List<E> list)

drop

public static <E> List<E> drop(List<E> list,
                               int n)

drop

public static <E> E[] drop(E... array)

drop

public static <E> E[] drop(E[] array,
                           int n)

compact

public static <E> List<E> compact(List<E> list)

compact

public static <E> E[] compact(E... array)

compact

public static <E> List<E> compact(List<E> list,
                                  E falsyValue)

compact

public static <E> E[] compact(E[] array,
                              E falsyValue)

compact

public List<T> compact()

compact

public List<T> compact(T falsyValue)

flatten

public static <E> List<E> flatten(List<?> list)

flatten

public static <E> List<E> flatten(List<?> list,
                                  boolean shallow)

flatten

public List<T> flatten()

flatten

public List<T> flatten(boolean shallow)

without

public static <E> List<E> without(List<E> list,
                                  E... values)

without

public static <E> E[] without(E[] array,
                              E... values)

uniq

public static <E> List<E> uniq(List<E> list)

uniq

public static <E> E[] uniq(E... array)

uniq

public static <K,E> Collection<E> uniq(Iterable<E> iterable,
                                       Function<E,K> func)

uniq

public static <K,E> E[] uniq(E[] array,
                             Function<E,K> func)

distinct

public static <E> List<E> distinct(List<E> list)

distinct

public static <E> E[] distinct(E... array)

distinctBy

public static <K,E> Collection<E> distinctBy(Iterable<E> iterable,
                                             Function<E,K> func)

distinctBy

public static <K,E> E[] distinctBy(E[] array,
                                   Function<E,K> func)

union

public static <E> List<E> union(List<E> list,
                                List<E>... lists)

unionWith

public List<T> unionWith(List<T>... lists)

union

public static <E> E[] union(E[]... arrays)

intersection

public static <E> List<E> intersection(List<E> list1,
                                       List<E> list2)

intersection

public static <E> List<E> intersection(List<E> list,
                                       List<E>... lists)

intersectionWith

public List<T> intersectionWith(List<T>... lists)

intersection

public static <E> E[] intersection(E[]... arrays)

difference

public static <E> List<E> difference(List<E> list1,
                                     List<E> list2)

difference

public static <E> List<E> difference(List<E> list,
                                     List<E>... lists)

differenceWith

public List<T> differenceWith(List<T>... lists)

difference

public static <E> E[] difference(E[]... arrays)

zip

public static <T> List<List<T>> zip(List<T>... lists)

unzip

public static <T> List<List<T>> unzip(List<T>... lists)

object

public static <K,V> List<Tuple<K,V>> object(List<K> keys,
                                            List<V> values)

findIndex

public static <E> int findIndex(List<E> list,
                                Predicate<E> pred)

findIndex

public static <E> int findIndex(E[] array,
                                Predicate<E> pred)

findLastIndex

public static <E> int findLastIndex(List<E> list,
                                    Predicate<E> pred)

findLastIndex

public static <E> int findLastIndex(E[] array,
                                    Predicate<E> pred)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(List<E> list,
                                                        E value)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(E[] array,
                                                        E value)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(List<E> list,
                                                        E value,
                                                        String propertyName)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(E[] array,
                                                        E value,
                                                        String propertyName)

indexOf

public static <E> int indexOf(List<E> list,
                              E value)

indexOf

public static <E> int indexOf(E[] array,
                              E value)

lastIndexOf

public static <E> int lastIndexOf(List<E> list,
                                  E value)

lastIndexOf

public static <E> int lastIndexOf(E[] array,
                                  E value)

range

public static int[] range(int stop)

range

public static int[] range(int start,
                          int stop)

range

public static int[] range(int start,
                          int stop,
                          int step)

chunk

public static <T> List<List<T>> chunk(Iterable<T> iterable,
                                      int size)

chunk

public List<List<T>> chunk(int size)

bind

public static <T,F> Function<F,T> bind(Function<F,T> function)

memoize

public static <T,F> Function<F,T> memoize(Function<F,T> function)

delay

public static <T> ScheduledFuture<T> delay(Supplier<T> function,
                                           int delayMilliseconds)

defer

public static <T> ScheduledFuture<T> defer(Supplier<T> function)

throttle

public static <T> Supplier<T> throttle(Supplier<T> function,
                                       int waitMilliseconds)

debounce

public static <T> Supplier<T> debounce(Supplier<T> function,
                                       int delayMilliseconds)

wrap

public static <T> Function<Void,T> wrap(Function<T,T> function,
                                        Function<Function<T,T>,T> wrapper)

negate

public static <E> Predicate<E> negate(Predicate<E> pred)

compose

public static <T> Function<T,T> compose(Function<T,T>... func)

after

public static <E> Supplier<E> after(int count,
                                    Supplier<E> function)

before

public static <E> Supplier<E> before(int count,
                                     Supplier<E> function)

once

public static <T> Supplier<T> once(Supplier<T> function)

keys

public static <K,V> Set<K> keys(Map<K,V> object)

values

public static <K,V> Collection<V> values(Map<K,V> object)

mapObject

public static <K,V> List<Tuple<K,V>> mapObject(Map<K,V> object,
                                               Function<? super V,V> func)

pairs

public static <K,V> List<Tuple<K,V>> pairs(Map<K,V> object)

invert

public static <K,V> List<Tuple<V,K>> invert(Map<K,V> object)

functions

public static List<String> functions(Object object)

methods

public static List<String> methods(Object object)

extend

public static <K,V> Map<K,V> extend(Map<K,V> destination,
                                    Map<K,V>... sources)

findKey

public static <E> E findKey(List<E> list,
                            Predicate<E> pred)

findKey

public static <E> E findKey(E[] array,
                            Predicate<E> pred)

findLastKey

public static <E> E findLastKey(List<E> list,
                                Predicate<E> pred)

findLastKey

public static <E> E findLastKey(E[] array,
                                Predicate<E> pred)

pick

public static <K,V> List<Tuple<K,V>> pick(Map<K,V> object,
                                          V... keys)

pick

public static <K,V> List<Tuple<K,V>> pick(Map<K,V> object,
                                          Predicate<V> pred)

omit

public static <K,V> List<Tuple<K,V>> omit(Map<K,V> object,
                                          V... keys)

omit

public static <K,V> List<Tuple<K,V>> omit(Map<K,V> object,
                                          Predicate<V> pred)

defaults

public static <K,V> Map<K,V> defaults(Map<K,V> object,
                                      Map<K,V> defaults)

clone

public static Object clone(Object obj)

clone

public static <E> E[] clone(E... iterable)

tap

public static <T> void tap(Iterable<T> iterable,
                           Consumer<? super T> func)

isMatch

public static <K,V> boolean isMatch(Map<K,V> object,
                                    Map<K,V> properties)

isEqual

public static boolean isEqual(Object object,
                              Object other)

isEmpty

public static <K,V> boolean isEmpty(Map<K,V> object)

isEmpty

public static <T> boolean isEmpty(Iterable<T> iterable)

isEmpty

public boolean isEmpty()

isArray

public static boolean isArray(Object object)

isObject

public static boolean isObject(Object object)

isFunction

public static boolean isFunction(Object object)

isString

public static boolean isString(Object object)

isNumber

public static boolean isNumber(Object object)

isDate

public static boolean isDate(Object object)

isRegExp

public static boolean isRegExp(Object object)

isError

public static boolean isError(Object object)

isBoolean

public static boolean isBoolean(Object object)

isNull

public static boolean isNull(Object object)

has

public static <K,V> boolean has(Map<K,V> object,
                                K key)

identity

public static <E> E identity(E value)

constant

public static <E> Supplier<E> constant(E value)

property

public static <K,V> Function<Map<K,V>,V> property(K key)

propertyOf

public static <K,V> Function<K,V> propertyOf(Map<K,V> object)

matcher

public static <K,V> Predicate<Map<K,V>> matcher(Map<K,V> object)

times

public static <E> void times(int count,
                             Supplier<E> function)

random

public static int random(int min,
                         int max)

random

public static int random(int max)

now

public static long now()

escape

public static String escape(String value)

unescape

public static String unescape(String value)

result

public static <E> Object result(Iterable<E> iterable,
                                Predicate<E> pred)

uniqueId

public static String uniqueId(String prefix)

uniquePassword

public static String uniquePassword()

template

public static <K,V> Template<Map<K,V>> template(String template)

format

public static String format(String template,
                            Object... params)

iterate

public static <T> Iterable<T> iterate(T seed,
                                      UnaryOperator<T> unaryOperator)

chain

public static <T> $.Chain<T> chain(List<T> list)

chain

public static <T> $.Chain<T> chain(Iterable<T> iterable)

chain

public static <T> $.Chain<T> chain(Iterable<T> iterable,
                                   int size)

chain

public static <T> $.Chain<T> chain(T... array)

chain

public static $.Chain<Integer> chain(int[] array)

chain

public $.Chain<T> chain()

mixin

public static void mixin(String funcName,
                         Function<String,String> func)

call

public Optional<String> call(String funcName)

sort

public static <T extends Comparable<T>> List<T> sort(Iterable<T> iterable)

sort

public static <T extends Comparable<T>> T[] sort(T... array)

sort

public List<Comparable> sort()

join

public static <T> String join(Iterable<T> iterable,
                              String separator)

join

public static <T> String join(Iterable<T> iterable)

join

public static <T> String join(T[] array,
                              String separator)

join

public static <T> String join(T[] array)

join

public String join(String separator)

join

public String join()

push

@SafeVarargs
public static <T> List<T> push(List<T> list,
                               T... values)

push

public List<T> push(T... values)

pop

public static <T> Tuple<T,List<T>> pop(List<T> list)

pop

public Tuple<T,List<T>> pop()

unshift

@SafeVarargs
public static <T> List<T> unshift(List<T> list,
                                  T... values)

unshift

public List<T> unshift(T... values)

shift

public static <T> Tuple<T,List<T>> shift(List<T> list)

shift

public Tuple<T,List<T>> shift()

concat

public static <T> T[] concat(T[] first,
                             T[]... other)

concat

public static <T> List<T> concat(Iterable<T> first,
                                 Iterable<T>... other)

concatWith

public List<T> concatWith(Iterable<T>... other)

slice

public static <T> List<T> slice(Iterable<T> iterable,
                                int start)

slice

public static <T> T[] slice(T[] array,
                            int start)

slice

public List<T> slice(int start)

slice

public static <T> List<T> slice(Iterable<T> iterable,
                                int start,
                                int end)

slice

public static <T> T[] slice(T[] array,
                            int start,
                            int end)

slice

public List<T> slice(int start,
                     int end)

reverse

public static <T> List<T> reverse(Iterable<T> iterable)

reverse

public static <T> T[] reverse(T... array)

reverse

public static List<Integer> reverse(int[] array)

reverse

public List<T> reverse()

getIterable

public Iterable<T> getIterable()

value

public Iterable<T> value()

getString

public Optional<String> getString()

setTimeout

public static <T> ScheduledFuture<T> setTimeout(Supplier<T> function,
                                                int delayMilliseconds)

clearTimeout

public static void clearTimeout(ScheduledFuture scheduledFuture)

setInterval

public static <T> ScheduledFuture setInterval(Supplier<T> function,
                                              int delayMilliseconds)

clearInterval

public static void clearInterval(ScheduledFuture scheduledFuture)

copyOf

public static <T> List<T> copyOf(Iterable<T> iterable)

copyOf

public List<T> copyOf()

copyOfRange

public static <T> List<T> copyOfRange(Iterable<T> iterable,
                                      int start,
                                      int end)

copyOfRange

public List<T> copyOfRange(int start,
                           int end)

elementAt

public static <T> T elementAt(List<T> list,
                              int index)

elementAt

public T elementAt(int index)

get

public static <T> T get(List<T> list,
                        int index)

get

public T get(int index)

set

public static <T> Tuple<T,List<T>> set(List<T> list,
                                       int index,
                                       T value)

set

public Tuple<T,List<T>> set(int index,
                            T value)

elementAtOrElse

public static <T> T elementAtOrElse(List<T> list,
                                    int index,
                                    T defaultValue)

elementAtOrElse

public T elementAtOrElse(int index,
                         T defaultValue)

elementAtOrNull

public static <T> T elementAtOrNull(List<T> list,
                                    int index)

elementAtOrNull

public T elementAtOrNull(int index)

lastIndex

public static <T> int lastIndex(Iterable<T> iterable)

lastIndex

public static <T> int lastIndex(T[] array)

lastIndex

public static int lastIndex(int[] array)

checkNotNull

public static <T> T checkNotNull(T reference)

checkNotNull

public static <T> T checkNotNull(T reference,
                                 Object errorMessage)

newArrayList

protected static <T> List<T> newArrayList()

newArrayList

protected static <T> List<T> newArrayList(Iterable<T> iterable)

newArrayList

protected static <T> List<T> newArrayList(Iterable<T> iterable,
                                          int size)

newIntegerList

protected static List<Integer> newIntegerList(int... array)

newArrayListWithExpectedSize

protected static <T> List<T> newArrayListWithExpectedSize(int size)

newLinkedHashSet

protected static <T> Set<T> newLinkedHashSet()

newLinkedHashSet

protected static <T> Set<T> newLinkedHashSet(Iterable<T> iterable)

newLinkedHashSetWithExpectedSize

protected static <T> Set<T> newLinkedHashSetWithExpectedSize(int size)

newLinkedHashMap

protected static <K,E> Map<K,E> newLinkedHashMap()

main

public static void main(String... args)