Uses of Interface
sharin.unlinq.Func2

Packages that use Func2
sharin.unlinq   
 

Uses of Func2 in sharin.unlinq
 

Methods in sharin.unlinq with parameters of type Func2
<A> A
BasicLookup.aggregate(A seed, Func2<A,Grouping<TKey,TValue>,A> func)
           
<A,R> R
BasicLookup.aggregate(A seed, Func2<A,Grouping<TKey,TValue>,A> func, Func<A,R> resultSelector)
           
<A> A
BasicDictionary.aggregate(A seed, Func2<A,Map.Entry<TKey,TValue>,A> func)
           
<A,R> R
BasicDictionary.aggregate(A seed, Func2<A,Map.Entry<TKey,TValue>,A> func, Func<A,R> resultSelector)
           
<A> A
Enumerable.aggregate(A seed, Func2<A,T,A> func)
           
<A> A
BasicOrderedEnumerable.aggregate(A seed, Func2<A,T,A> func)
           
<A> A
BasicEnumerableList.aggregate(A seed, Func2<A,T,A> func)
           
<A> A
BasicEnumerable.aggregate(A seed, Func2<A,T,A> func)
           
<A,R> R
Enumerable.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicOrderedEnumerable.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicEnumerableList.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicEnumerable.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
 Grouping<TKey,TValue> BasicLookup.aggregate(Func2<Grouping<TKey,TValue>,Grouping<TKey,TValue>,Grouping<TKey,TValue>> func)
           
 Map.Entry<TKey,TValue> BasicDictionary.aggregate(Func2<Map.Entry<TKey,TValue>,Map.Entry<TKey,TValue>,Map.Entry<TKey,TValue>> func)
           
 T Enumerable.aggregate(Func2<T,T,T> func)
           
 T BasicOrderedEnumerable.aggregate(Func2<T,T,T> func)
           
 T BasicEnumerableList.aggregate(Func2<T,T,T> func)
           
 T BasicEnumerable.aggregate(Func2<T,T,T> func)
           
<K,E,R> Enumerable<R>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func2<K,Enumerable<Grouping<TKey,TValue>>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func2<K,Enumerable<Map.Entry<TKey,TValue>>,R> resultSelector)
           
<K,E,R> Enumerable<R>
Enumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
Enumerable.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicLookup.groupJoin(Enumerable<I> inner, Func<Grouping<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Grouping<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicDictionary.groupJoin(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
Enumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicOrderedEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerableList.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicLookup.join(Enumerable<I> inner, Func<Grouping<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Grouping<TKey,TValue>,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicDictionary.join(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
Enumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicOrderedEnumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerableList.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<R> Enumerable<R>
BasicLookup.select(Func2<Grouping<TKey,TValue>,Integer,R> selector)
           
<R> Enumerable<R>
BasicDictionary.select(Func2<Map.Entry<TKey,TValue>,Integer,R> selector)
           
<R> Enumerable<R>
Enumerable.select(Func2<T,Integer,R> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.select(Func2<T,Integer,R> selector)
           
<R> Enumerable<R>
BasicEnumerableList.select(Func2<T,Integer,R> selector)
           
<R> Enumerable<R>
BasicEnumerable.select(Func2<T,Integer,R> selector)
           
<C,R> Enumerable<R>
BasicLookup.selectMany(Func<Grouping<TKey,TValue>,Enumerable<C>> collectionSelector, Func2<Grouping<TKey,TValue>,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicDictionary.selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<C,R> Enumerable<R>
Enumerable.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerableList.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerable.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Grouping<TKey,TValue>,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Grouping<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.skipWhile(Func2<Grouping<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.skipWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.takeWhile(Func2<Grouping<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.takeWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.where(Func2<Grouping<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.where(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.where(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.where(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.where(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.where(Func2<T,Integer,Boolean> predicate)
           
 



Copyright © 2009 SHU. All Rights Reserved.