com.yy.mediaframework.utils

Class FP

java.lang.Object

com.yy.mediaframework.utils.FP

public class FP
extends java.lang.Object

A functional programming style utility

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	FP.BinaryFunc<R,A,B>
static class	FP.Eq<A>
static class	FP.M Tree based Map (ordable)
static class	FP.Pred<A>
static class	FP.Tuple<A,B,C>
static interface	FP.UnaryFunc<R,A>

Constructor Summary

Constructors

Constructor and Description
FP()

Method Summary

Modifier and Type	Method and Description
static <E> java.util.List<E>	add(java.util.List<E> xs, E x) Safe add element to a list even the list is empty
static int[]	concat(int[] xs, int[] ys)
static <T> java.util.List<T>	concat(java.util.List<T> xs, java.util.List<T> ys) Safe concatenation Note that the first list is MUTATED if it isn't empty.
static <T> T[]	concat(T[] xs, T[] ys)
static <E> java.util.LinkedList<E>	cons(E x, java.util.LinkedList<E> xs)
static <T> void	convert(T[] dst, java.lang.Object[] src)
static <E> java.util.List<E>	del(java.util.List<E> xs, E x)
static <E> java.util.List<E>	delBy(FP.Eq<E> cmp, java.util.List<E> xs, E x) Safe remove the first occurrent of x in xs
static <T> java.util.List<T>	diff(java.util.List<T> xs, java.util.List<T> ys)
static <T> java.util.List<T>	diffBy(FP.Eq<T> eq, java.util.List<T> xs, java.util.List<T> ys) list difference xs \\ ys invariant: (xs ++ ys) \\ xs == ys
static <E> java.util.List<E>	drop(int n, java.util.List<E> xs) Safe drop the first n elements from a list
static java.lang.String	drop(int n, java.lang.String s)
static <E> java.util.List<E>	dropWhile(FP.Pred<E> p, java.util.List<E> xs)
static <T> boolean	elem(T x, java.util.Collection<T> xs)
static <T> boolean	elem(T x, T[] xs)
static boolean	empty(java.lang.CharSequence s) Test if a abstract string is either NIL or empty
static boolean	empty(java.util.Collection<?> xs) Test if a collection is either NIL or empty
static boolean	empty(int[] xs)
static boolean	empty(long[] xs)
static boolean	empty(java.util.Map<?,?> m)
static boolean	empty(android.util.SparseArray<?> xs)
static boolean	empty(android.util.SparseIntArray xs)
static <T> boolean	empty(T[] xs) Test if an array is either NIL or empty
static boolean	eq(java.lang.Object a, java.lang.Object b) Safe equal predicate
static <E> java.util.List<E>	filter(FP.Pred<E> p, java.util.List<E> xs) filtering
static <E> E	find(E x, java.util.List<E> xs) Find among a list for an element
static <E> E	find(FP.Pred<E> p, java.util.List<E> xs) Find among a list by using predicate function p
static <E> int	findIndex(FP.Pred<E> p, java.util.List<E> xs)
static <E> E	first(java.util.Collection<E> xs)
static <E> E	first(java.util.List<E> xs)
static <S,E> S	fold(FP.BinaryFunc<S,S,E> f, S s, java.util.Collection<E> xs) folding left
static <E> E	head(java.util.LinkedList<E> xs)
static <E> java.util.List<E>	insert(java.util.Comparator<E> cmp, E x, java.util.List<E> xs) ordered insertion.
static <E> boolean	isPrefixOf(java.util.List<E> prefix, java.util.List<E> xs)
static boolean	isPrefixOf(java.lang.String prefix, java.lang.String s)
static <E> E	last(java.util.List<E> xs) Access the last element of a list
static int	lastIndex(java.util.List<?> xs) Safe return the index of the last element even if the list is NIL
static int	length(java.lang.CharSequence s)
static int	length(java.util.Collection<?> xs) Defined just as alias of 'size'.
static int	length(int[] xs)
static int	length(java.util.Map<?,?> m)
static int	length(android.util.SparseArray<?> xs)
static int	length(android.util.SparseIntArray xs)
static <T> int	length(T[] xs)
static int	limit(int x, int low, int high)
static <E> E	lookup(int k, android.util.SparseArray<E> xs)
static <K,V> V	lookup(K k, java.util.List<android.util.Pair<K,V>> xs) looks up a key in an association list (which is realized by pair)
static <A,B,C> FP.Tuple<A,B,C>	makeTuple(A a, B b, C c)
static <A,B> java.util.List<B>	map(FP.UnaryFunc<B,A> f, java.util.List<A> xs) mapping
static int	maximum(int... xs)
static <E> FP.Pred<E>	negate(FP.Pred<E> p)
static <E> java.util.List<E>	nub(java.util.List<E> xs) Remove duplicate items by using Object.equals().
static <E> java.util.List<E>	nubBy(FP.Eq<E> cmp, java.util.List<E> xs) Remove duplicated items by using a compare function, O(N^2) time bound
static int	ord(boolean x)
static int	ord(java.lang.Integer x)
static <E> E[]	ref(E[] xs)
static int[]	ref(int[] xs)
static <E> java.util.List<E>	ref(java.util.List<E> xs) Safe reference to a list even it's NIL
static java.lang.String	ref(java.lang.String s)
static <E> java.util.List<E>	replicate(int n, java.util.concurrent.Callable<E> gen)
static <E> java.util.List<E>	replicate(int n, E x)
static <E> E	second(java.util.List<E> xs)
static <T> void	shift(java.util.List<T> xs, int from, int to)
static <T> void	shift(T[] xs, int from, int to)
static int	size(java.lang.CharSequence s)
static int	size(java.util.Collection<?> xs) Safe return the size of a collection even it's NIL
static int	size(int[] xs)
static int	size(java.util.Map<?,?> m)
static int	size(android.util.SparseArray<?> xs)
static int	size(android.util.SparseIntArray xs)
static <T> int	size(T[] xs)
static <E> java.util.List<E>	sort(java.util.Comparator<E> cmp, java.util.List<E> xs) A wrapper to java.util.Collections.sort().
static <E> android.util.Pair<java.util.List<E>,java.util.List<E>>	span(FP.Pred<E> p, java.util.List<E> xs) span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list.
static int	sum(java.lang.Integer[] xs)
static int	sum(java.util.List<java.lang.Integer> xs)
static long	sum(java.lang.Long[] xs)
static <T> void	swap(java.util.List<T> xs, int i, int j)
static <T> void	swap(T[] xs, int i, int j)
static <E> java.util.LinkedList<E>	tail(java.util.LinkedList<E> xs)
static <E> java.util.List<E>	take(int n, java.util.List<E> xs) Safe take the first n elements from a list
static <K,V> java.util.Map<K,V>	take(int n, java.util.Map<K,V> xs)
static java.lang.String	take(int n, java.lang.String s)
static <E> java.util.List<E>	takeWhile(FP.Pred<E> p, java.util.List<E> xs)
static int[]	toArray(java.util.List<java.lang.Integer> xs)
static <E> java.util.List<E>	toList(java.util.Collection<? extends E> xs) Safe convert a collection to list even it's NIL
static java.util.List<java.lang.Integer>	toList(int[] xs)
static java.util.List<java.lang.Long>	toList(long[] xs)
static <E> java.util.List<android.util.Pair<java.lang.Integer,E>>	toList(android.util.SparseArray<E> xs)
static java.util.List<android.util.Pair<java.lang.Integer,java.lang.Integer>>	toList(android.util.SparseIntArray xs)
static <T> java.util.List<T>	toList(T x)
static <T> java.util.List<T>	toList(T[] xs) Safe convert an array to list even it's NIL
static <T> java.util.List<T>	union(java.util.List<T> xs, java.util.List<T> ys)
static <T> java.util.List<T>	unionBy(FP.Eq<T> cmp, java.util.List<T> xs, java.util.List<T> ys) Safe union, O(N^2) time bound Note that 1.
static <A,B> java.util.List<android.util.Pair<A,B>>	zip(java.util.List<A> as, java.util.List<B> bs) Safe zipper

Methods inherited from class java.lang.Object

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

Constructor Detail

FP

public FP()

Method Detail

makeTuple

public static <A,B,C> FP.Tuple<A,B,C> makeTuple(A a,
                                                B b,
                                                C c)

negate

public static <E> FP.Pred<E> negate(FP.Pred<E> p)

limit

public static int limit(int x,
                        int low,
                        int high)

maximum

public static int maximum(int... xs)

find

public static <E> E find(FP.Pred<E> p,
                         java.util.List<E> xs)

Find among a list by using predicate function p

find

public static <E> E find(E x,
                         java.util.List<E> xs)

Find among a list for an element

findIndex

public static <E> int findIndex(FP.Pred<E> p,
                                java.util.List<E> xs)

lookup

public static <K,V> V lookup(K k,
                             java.util.List<android.util.Pair<K,V>> xs)

looks up a key in an association list (which is realized by pair)

lookup

public static <E> E lookup(int k,
                           android.util.SparseArray<E> xs)

nubBy

public static <E> java.util.List<E> nubBy(FP.Eq<E> cmp,
                                          java.util.List<E> xs)

Remove duplicated items by using a compare function, O(N^2) time bound

nub

public static <E> java.util.List<E> nub(java.util.List<E> xs)

Remove duplicate items by using Object.equals(). O(N^2) time bound The name nub means `essence'.

empty

public static boolean empty(java.util.Collection<?> xs)

Test if a collection is either NIL or empty

empty

public static <T> boolean empty(T[] xs)

Test if an array is either NIL or empty

empty

public static boolean empty(android.util.SparseArray<?> xs)

empty

public static boolean empty(android.util.SparseIntArray xs)

empty

public static boolean empty(int[] xs)

empty

public static boolean empty(long[] xs)

empty

public static boolean empty(java.lang.CharSequence s)

Test if a abstract string is either NIL or empty

empty

public static boolean empty(java.util.Map<?,?> m)

size

public static int size(java.util.Collection<?> xs)

Safe return the size of a collection even it's NIL

size

public static int size(java.lang.CharSequence s)

size

public static <T> int size(T[] xs)

size

public static int size(int[] xs)

size

public static int size(java.util.Map<?,?> m)

size

public static int size(android.util.SparseArray<?> xs)

size

public static int size(android.util.SparseIntArray xs)

length

public static int length(java.util.Collection<?> xs)

Defined just as alias of 'size'.

length

public static int length(java.lang.CharSequence s)

length

public static <T> int length(T[] xs)

length

public static int length(int[] xs)

length

public static int length(java.util.Map<?,?> m)

length

public static int length(android.util.SparseArray<?> xs)

length

public static int length(android.util.SparseIntArray xs)

elem

public static <T> boolean elem(T x,
                               T[] xs)

elem

public static <T> boolean elem(T x,
                               java.util.Collection<T> xs)

swap

public static <T> void swap(java.util.List<T> xs,
                            int i,
                            int j)

swap

public static <T> void swap(T[] xs,
                            int i,
                            int j)

shift

public static <T> void shift(java.util.List<T> xs,
                             int from,
                             int to)

shift

public static <T> void shift(T[] xs,
                             int from,
                             int to)

add

public static <E> java.util.List<E> add(java.util.List<E> xs,
                                        E x)

Safe add element to a list even the list is empty

delBy

public static <E> java.util.List<E> delBy(FP.Eq<E> cmp,
                                          java.util.List<E> xs,
                                          E x)

Safe remove the first occurrent of x in xs

del

public static <E> java.util.List<E> del(java.util.List<E> xs,
                                        E x)

span

public static <E> android.util.Pair<java.util.List<E>,java.util.List<E>> span(FP.Pred<E> p,
                                                                              java.util.List<E> xs)

span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list.

take

public static <E> java.util.List<E> take(int n,
                                         java.util.List<E> xs)

Safe take the first n elements from a list

take

public static java.lang.String take(int n,
                                    java.lang.String s)

take

public static <K,V> java.util.Map<K,V> take(int n,
                                            java.util.Map<K,V> xs)

takeWhile

public static <E> java.util.List<E> takeWhile(FP.Pred<E> p,
                                              java.util.List<E> xs)

drop

public static <E> java.util.List<E> drop(int n,
                                         java.util.List<E> xs)

Safe drop the first n elements from a list

drop

public static java.lang.String drop(int n,
                                    java.lang.String s)

dropWhile

public static <E> java.util.List<E> dropWhile(FP.Pred<E> p,
                                              java.util.List<E> xs)

head

public static <E> E head(java.util.LinkedList<E> xs)

tail

public static <E> java.util.LinkedList<E> tail(java.util.LinkedList<E> xs)

cons

public static <E> java.util.LinkedList<E> cons(E x,
                                               java.util.LinkedList<E> xs)

first

public static <E> E first(java.util.List<E> xs)

second

public static <E> E second(java.util.List<E> xs)

last

public static <E> E last(java.util.List<E> xs)

Access the last element of a list

lastIndex

public static int lastIndex(java.util.List<?> xs)

Safe return the index of the last element even if the list is NIL

Returns:

-1 if the list is NIL

first

public static <E> E first(java.util.Collection<E> xs)

toList

public static <E> java.util.List<E> toList(java.util.Collection<? extends E> xs)

Safe convert a collection to list even it's NIL

toList

public static <T> java.util.List<T> toList(T x)

toList

public static <T> java.util.List<T> toList(T[] xs)

Safe convert an array to list even it's NIL

toList

public static java.util.List<java.lang.Integer> toList(int[] xs)

toList

public static java.util.List<java.lang.Long> toList(long[] xs)

toList

public static <E> java.util.List<android.util.Pair<java.lang.Integer,E>> toList(android.util.SparseArray<E> xs)

toList

public static java.util.List<android.util.Pair<java.lang.Integer,java.lang.Integer>> toList(android.util.SparseIntArray xs)

toArray

public static int[] toArray(java.util.List<java.lang.Integer> xs)

ref

public static <E> java.util.List<E> ref(java.util.List<E> xs)

Safe reference to a list even it's NIL

Returns:

reference to the list if it's not NIL, or an empty list.

ref

public static <E> E[] ref(E[] xs)

ref

public static int[] ref(int[] xs)

ref

public static java.lang.String ref(java.lang.String s)

zip

public static <A,B> java.util.List<android.util.Pair<A,B>> zip(java.util.List<A> as,
                                                               java.util.List<B> bs)

Safe zipper

eq

public static boolean eq(java.lang.Object a,
                         java.lang.Object b)

Safe equal predicate

isPrefixOf

public static boolean isPrefixOf(java.lang.String prefix,
                                 java.lang.String s)

isPrefixOf

public static <E> boolean isPrefixOf(java.util.List<E> prefix,
                                     java.util.List<E> xs)

convert

public static <T> void convert(T[] dst,
                               java.lang.Object[] src)

concat

public static <T> java.util.List<T> concat(java.util.List<T> xs,
                                           java.util.List<T> ys)

Safe concatenation Note that the first list is MUTATED if it isn't empty.

concat

public static <T> T[] concat(T[] xs,
                             T[] ys)

concat

public static int[] concat(int[] xs,
                           int[] ys)

unionBy

public static <T> java.util.List<T> unionBy(FP.Eq<T> cmp,
                                            java.util.List<T> xs,
                                            java.util.List<T> ys)

Safe union, O(N^2) time bound Note that 1. the first list is mutated if it isn't empty. 2. Only the duplicated elements in the second list is removed, those duplicated ones in first is kept. If the order needn't be kept, we strongly recommend to use set instead!

union

public static <T> java.util.List<T> union(java.util.List<T> xs,
                                          java.util.List<T> ys)

diffBy

public static <T> java.util.List<T> diffBy(FP.Eq<T> eq,
                                           java.util.List<T> xs,
                                           java.util.List<T> ys)

list difference xs \\ ys invariant: (xs ++ ys) \\ xs == ys

diff

public static <T> java.util.List<T> diff(java.util.List<T> xs,
                                         java.util.List<T> ys)

map

public static <A,B> java.util.List<B> map(FP.UnaryFunc<B,A> f,
                                          java.util.List<A> xs)

mapping

filter

public static <E> java.util.List<E> filter(FP.Pred<E> p,
                                           java.util.List<E> xs)

filtering

fold

public static <S,E> S fold(FP.BinaryFunc<S,S,E> f,
                           S s,
                           java.util.Collection<E> xs)

folding left

insert

public static <E> java.util.List<E> insert(java.util.Comparator<E> cmp,
                                           E x,
                                           java.util.List<E> xs)

ordered insertion. O(\lg N) algorithm as it uses binary search Please ensure the list support random access, so that the binary search make sense.

sort

public static <E> java.util.List<E> sort(java.util.Comparator<E> cmp,
                                         java.util.List<E> xs)

A wrapper to java.util.Collections.sort(). for chained style usage.

sum

public static int sum(java.lang.Integer[] xs)

sum

public static long sum(java.lang.Long[] xs)

sum

public static int sum(java.util.List<java.lang.Integer> xs)

ord

public static int ord(boolean x)

ord

public static int ord(java.lang.Integer x)

replicate

public static <E> java.util.List<E> replicate(int n,
                                              E x)

replicate

public static <E> java.util.List<E> replicate(int n,
                                              java.util.concurrent.Callable<E> gen)