public LinqDictionary <Key, Value> ToDictionary <Key, Value>(SigilFunc <T, Key> k, SigilFunc <T, Value> v)
{
return(LinqAlternative.ToDictionary(InnerEnumerable(), k, v));
}
public T FirstOrDefault()
{
return(LinqAlternative.FirstOrDefault(InnerEnumerable()));
}
public LinqRoot <V> Cast <V>()
{
return(LinqAlternative.Cast <V>(InnerEnumerable()));
}
public LinqRoot <V> SelectMany <V>(SigilFunc <T, IEnumerable <V> > p)
{
return(LinqAlternative.SelectMany(InnerEnumerable(), p));
}
public LinqRoot <T> Skip(int n)
{
return(LinqAlternative.Skip(InnerEnumerable(), n));
}
public T SingleOrDefault()
{
return(LinqAlternative.SingleOrDefault(InnerEnumerable()));
}
public LinqRoot <T> OrderByDescending <V>(SigilFunc <T, V> p)
{
return(LinqAlternative.OrderByDescending(InnerEnumerable(), p));
}
public LinqRoot <T> Reverse()
{
return(LinqAlternative.Reverse(InnerEnumerable()));
}
public int Count()
{
return(LinqAlternative.Count(InnerEnumerable()));
}
public LinqRoot <IGrouping <K, T> > GroupBy <K>(SigilFunc <T, K> p)
{
return(LinqAlternative.GroupBy(InnerEnumerable(), p));
}
public LinqRoot <T> Distinct(IEqualityComparer <T> c)
{
return(LinqAlternative.Distinct(InnerEnumerable(), c));
}
public LinqRoot <T> Distinct()
{
return(LinqAlternative.Distinct(InnerEnumerable()));
}
public LinqRoot <V> SelectMany <V>(SigilFunc <T, LinqRoot <V> > p)
{
return(LinqAlternative.SelectMany(InnerEnumerable(), x => p(x).AsEnumerable()));
}
public T ElementAt(int n)
{
return(LinqAlternative.ElementAt(InnerEnumerable(), n));
}
public void Each(Action <T> a)
{
LinqAlternative.Each(InnerEnumerable(), a);
}
public T Last()
{
return(LinqAlternative.Last(InnerEnumerable()));
}
public int Count(SigilFunc <T, bool> p)
{
return(LinqAlternative.Count(InnerEnumerable(), p));
}
public bool All(SigilFunc <T, bool> p)
{
return(LinqAlternative.All(InnerEnumerable(), p));
}
public LinqRoot <V> Select <V>(SigilFunc <T, int, V> p)
{
return(LinqAlternative.Select(InnerEnumerable(), p));
}
public LinqRoot <T> Where(SigilFunc <T, bool> p)
{
return(LinqAlternative.Where(InnerEnumerable(), p));
}
public LinqList <T> ToList()
{
return(LinqAlternative.ToList(InnerEnumerable()));
}
public T SingleOrDefault(SigilFunc <T, bool> p)
{
return(LinqAlternative.SingleOrDefault(InnerEnumerable(), p));
}
public T[] ToArray()
{
return(LinqAlternative.ToArray(InnerEnumerable()));
}
public bool Contains(T i)
{
return(LinqAlternative.Contains(InnerEnumerable(), i));
}
public V Aggregate <V>(V seed, SigilFunc <V, T, V> p)
{
return(LinqAlternative.Aggregate(InnerEnumerable(), seed, p));
}
