// Ms-PL License
|
// linq.js C# backport
|
// http://linqjs.codeplex.com/
|
|
using System.Collections.Generic;
|
using System.Text;
|
using System.Collections;
|
|
namespace System.Linq
|
{
|
public static class LinqJS
|
{
|
#region Generating Methods
|
|
public static IEnumerable<T> Choice<T>(params T[] values)
|
{
|
var rand = new Random();
|
while (true)
|
{
|
yield return values[rand.Next(values.Length)];
|
}
|
}
|
|
public static IEnumerable<T> Cycle<T>(params T[] values)
|
{
|
while (true)
|
{
|
foreach (var item in values)
|
{
|
yield return item;
|
}
|
}
|
}
|
|
public static IEnumerable<int> Range(int start, int count)
|
{
|
return Range(start, count, 1);
|
}
|
|
public static IEnumerable<int> Range(int start, int count, int step)
|
{
|
return ToInfinity(start, step).Take(count);
|
}
|
|
public static IEnumerable<int> RangeDown(int start, int count)
|
{
|
return RangeDown(start, count, 1);
|
}
|
|
public static IEnumerable<int> RangeDown(int start, int count, int step)
|
{
|
return ToNegativeInfinity(start, step).Take(count);
|
}
|
|
public static IEnumerable<int> RangeTo(int from, int to)
|
{
|
return RangeTo(from, to, 1);
|
}
|
|
public static IEnumerable<int> RangeTo(int from, int to, int step)
|
{
|
return (from < to)
|
? ToInfinity(from, step).TakeWhile(i => i <= to)
|
: ToNegativeInfinity(from, step).TakeWhile(i => i >= to);
|
}
|
|
public static IEnumerable<T> Return<T>(T value)
|
{
|
return Enumerable.Repeat(value, 1);
|
}
|
|
public static IEnumerable<T> Generate<T>(Func<T> func)
|
{
|
while (true)
|
{
|
yield return func();
|
}
|
}
|
|
public static IEnumerable<T> Generate<T>(Func<T> func, int count)
|
{
|
return Generate(func).Take(count);
|
}
|
|
public static IEnumerable<int> ToInfinity()
|
{
|
return ToInfinity(0);
|
}
|
|
public static IEnumerable<int> ToInfinity(int start)
|
{
|
return ToInfinity(start, 1);
|
}
|
|
public static IEnumerable<int> ToInfinity(int start, int step)
|
{
|
while (true)
|
{
|
yield return start;
|
start += step;
|
}
|
}
|
|
public static IEnumerable<int> ToNegativeInfinity()
|
{
|
return ToNegativeInfinity(0);
|
}
|
|
public static IEnumerable<int> ToNegativeInfinity(int start)
|
{
|
return ToNegativeInfinity(start, 1);
|
}
|
|
public static IEnumerable<int> ToNegativeInfinity(int start, int step)
|
{
|
return ToInfinity(start, -step);
|
}
|
|
public static IEnumerable<T> Unfold<T>(T seed, Func<T, T> func)
|
{
|
yield return seed;
|
var value = seed;
|
while (true)
|
{
|
value = func(value);
|
yield return value;
|
}
|
}
|
|
#endregion
|
|
#region Projection and Filtering Methods
|
|
public static IEnumerable<T> CascadeDepthFirst<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
|
{
|
return source.CascadeDepthFirst(selector, t => t);
|
}
|
|
public static IEnumerable<R> CascadeDepthFirst<T, R>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector, Func<T, R> resultSelector)
|
{
|
return source.CascadeDepthFirst(selector, (t, _) => resultSelector(t));
|
}
|
|
public static IEnumerable<R> CascadeDepthFirst<T, R>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector, Func<T, int, R> resultSelector)
|
{
|
return source.DepthFirstSearch(selector, 0).Select(kvp => resultSelector(kvp.Key, kvp.Value));
|
}
|
|
private static IEnumerable<KeyValuePair<T, int>> DepthFirstSearch<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector, int depth)
|
{
|
foreach (var item in source)
|
{
|
yield return new KeyValuePair<T, int>(item, depth);
|
foreach (var subitem in selector(item).DepthFirstSearch(selector, depth + 1))
|
{
|
yield return subitem;
|
}
|
}
|
}
|
|
public static IEnumerable<T> CascadeBreadthFirst<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
|
{
|
return source.CascadeBreadthFirst(selector, t => t);
|
}
|
|
public static IEnumerable<R> CascadeBreadthFirst<T, R>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector, Func<T, R> resultSelector)
|
{
|
return source.CascadeBreadthFirst(selector, (t, _) => resultSelector(t));
|
}
|
|
/// <see cref="http://d.hatena.ne.jp/NyaRuRu/20080115/p1"/>
|
public static IEnumerable<R> CascadeBreadthFirst<T, R>(this IEnumerable<T> source, Func<T, IEnumerable<T>> selector, Func<T, int, R> resultSelector)
|
{
|
var depth = 0;
|
var buffer = source.ToArray();
|
while (buffer.Any())
|
{
|
foreach (var item in buffer) yield return resultSelector(item, depth);
|
buffer = buffer.SelectMany(selector).ToArray();
|
depth++;
|
}
|
}
|
|
public static IEnumerable<T> Flatten<T>(this IEnumerable source)
|
{
|
foreach (var item in source)
|
{
|
var subsource = item as IEnumerable;
|
if (subsource != null)
|
{
|
foreach (var subitem in subsource.Flatten<T>())
|
{
|
yield return subitem;
|
}
|
}
|
else
|
{
|
yield return (T)item;
|
}
|
}
|
}
|
|
public static IEnumerable<R> Pairwise<T, R>(this IEnumerable<T> source, Func<T, T, R> selector)
|
{
|
var isFirst = true;
|
var prev = default(T);
|
foreach (var item in source)
|
{
|
if (isFirst)
|
{
|
prev = item;
|
isFirst = false;
|
continue;
|
}
|
yield return selector(prev, item);
|
prev = item;
|
}
|
}
|
|
public static IEnumerable<T> Scan<T>(this IEnumerable<T> source, Func<T, T, T> func)
|
{
|
var isFirst = true;
|
var value = default(T);
|
foreach (var item in source)
|
{
|
if (isFirst)
|
{
|
isFirst = false;
|
value = item;
|
yield return value;
|
continue;
|
}
|
value = func(value, item);
|
yield return value;
|
}
|
}
|
|
public static IEnumerable<TA> Scan<T, TA>(this IEnumerable<T> source, TA seed, Func<TA, T, TA> func)
|
{
|
return source.Scan(seed, func, x => x);
|
}
|
|
public static IEnumerable<TR> Scan<T, TA, TR>(this IEnumerable<T> source, TA seed, Func<TA, T, TA> func, Func<TA, TR> resultSelector)
|
{
|
yield return resultSelector(seed);
|
var value = seed;
|
foreach (var item in source)
|
{
|
value = func(value, item);
|
yield return resultSelector(value);
|
}
|
}
|
|
//Obsolete .NET 4]
|
//public static IEnumerable<R> Zip<T1, T2, R>(this IEnumerable<T1> source, IEnumerable<T2> source2, Func<T1, T2, R> selector)
|
//{
|
// using (var e1 = source.GetEnumerator())
|
// using (var e2 = source2.GetEnumerator())
|
// {
|
// while (e1.MoveNext() && e2.MoveNext())
|
// {
|
// yield return selector(e1.Current, e2.Current);
|
// }
|
// }
|
//}
|
|
#endregion
|
|
#region Set Methods
|
|
public static IEnumerable<T> Insert<T>(this IEnumerable<T> source, int index, IEnumerable<T> second)
|
{
|
var count = 0;
|
foreach (var item in source)
|
{
|
if (count++ == index)
|
{
|
foreach (var subitem in second) yield return subitem;
|
}
|
yield return item;
|
}
|
}
|
|
#endregion
|
|
#region Ordering Methods
|
|
public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
|
{
|
var rand = new Random();
|
return source.OrderBy(_ => rand.Next());
|
}
|
|
#endregion
|
|
#region Paging Methods
|
|
public static int IndexOf<T>(this IEnumerable<T> source, T value)
|
{
|
return source.IndexOf(value, EqualityComparer<T>.Default);
|
}
|
|
public static int IndexOf<T>(this IEnumerable<T> source, T value, EqualityComparer<T> comparer)
|
{
|
var index = 0;
|
foreach (var item in source)
|
{
|
if (comparer.Equals(value, item)) return index;
|
index++;
|
}
|
return -1;
|
}
|
|
public static int LastIndexOf<T>(this IEnumerable<T> source, T value)
|
{
|
return source.LastIndexOf(value, EqualityComparer<T>.Default);
|
}
|
|
public static int LastIndexOf<T>(this IEnumerable<T> source, T value, EqualityComparer<T> comparer)
|
{
|
var index = 0;
|
var result = -1;
|
foreach (var item in source)
|
{
|
if (comparer.Equals(value, item)) result = index;
|
index++;
|
}
|
return result;
|
}
|
|
#endregion
|
|
#region Convert Methods
|
|
public static string ToStringJoin<T>(this IEnumerable<T> source)
|
{
|
return source.ToStringJoin("");
|
}
|
|
public static string ToStringJoin<T>(this IEnumerable<T> source, string separator)
|
{
|
var index = 0;
|
return source.Aggregate(new StringBuilder(), (sb, v) =>
|
(index++ == 0) ? sb.Append(v) : sb.AppendFormat("{0}{1}", separator, v))
|
.ToString();
|
}
|
|
public static string ToStringJoin<T, R>(this IEnumerable<T> source, string separator, Func<T, R> selector)
|
{
|
return source.Select(selector).ToStringJoin(separator);
|
}
|
|
#endregion
|
|
#region Action Methods
|
|
public static IEnumerable<T> Do<T>(this IEnumerable<T> source, Action<T> action)
|
{
|
return source.Do((v, i) => action(v));
|
}
|
|
public static IEnumerable<T> Do<T>(this IEnumerable<T> source, Action<T, int> action)
|
{
|
var index = 0;
|
foreach (var item in source)
|
{
|
action(item, index++);
|
yield return item;
|
}
|
}
|
|
public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
|
{
|
source.ForEach((v, i) => action(v));
|
}
|
|
public static void ForEach<T>(this IEnumerable<T> source, Action<T, int> action)
|
{
|
source.Do(action).Force();
|
}
|
|
public static void Write<T>(this IEnumerable<T> source)
|
{
|
source.Write("");
|
}
|
|
public static void Write<T>(this IEnumerable<T> source, string separator)
|
{
|
source.ForEach((t, index) => Console.Write((index == 0) ? t.ToString() : separator + t));
|
}
|
|
public static void Write<T, R>(this IEnumerable<T> source, string separator, Func<T, R> selector)
|
{
|
source.Select(selector).Write(separator);
|
}
|
|
public static void WriteLine<T>(this IEnumerable<T> source)
|
{
|
source.ForEach(t => Console.WriteLine(t));
|
}
|
|
public static void WriteLine<T, R>(this IEnumerable<T> source, Func<T, R> selector)
|
{
|
source.Select(selector).WriteLine();
|
}
|
|
#endregion
|
|
#region For Debug Methods
|
|
public static void Force<T>(this IEnumerable<T> source)
|
{
|
using (var e = source.GetEnumerator())
|
{
|
while (e.MoveNext()) ;
|
}
|
}
|
|
public static IEnumerable<T> Trace<T>(this IEnumerable<T> source)
|
{
|
return source.Do(t => Diagnostics.Trace.WriteLine(t));
|
}
|
|
#endregion
|
}
|
}
|
