Dizzy published

Two questions:

1. How useful is it to have names which match existing nomenclature, especially when equivalent functions already exist under different names in .NET 3.5?

For example, Manipulation.Map() is Enumerable.Select(), and Manipulation.Filter() is Enumerable.Where().

Given that the methods are already in .NET (if only by a different name), what is the advantage to using existing nomenclature?  Education?  Or something else?

2. Would you be interested in merging with another library?

Mono.Rocks (http://www.mono-project.com/Rocks) is an effort to maintain a variety of useful extension methods, and already contains your Traversal.Repeat() as Mono.Rocks.IEnumerableRocks.Repeat().  

(Furthermore, your Traversal.Repeat() is buggy, as the argument checking exceptions won't be generated until .MoveNext() is invoked on the iterator, i.e. argument checking is itself lazy, which I doubt is intentional).

Mono.Rocks is under MIT/X11, which is only slightly more liberal than your current Ms-PL license, if licensing is a concern.

Pingback from blog.cwa.me.uk

Reflective Perspective - Chris Alcock  » The Morning Brew #111

Pingback from alvinashcraft.com

Dew Drop – June 10, 2008 | Alvin Ashcraft's Morning Dew

Might I suggest following PLinq for the parallel version?  That is, instead of having a ParallelMap which is a parallel version of Map, instead have an AsParallel() extension method which returns an IParallelEnumerable<T>, and then create versions of Map() et. al that consume IParallelEnumerable<T>:


interface IParallelEnumerable<T> : IEnumerable<T> {}

static class DizzyEnumerable {

class ParallelEnumerable<T> : IParallelEnumerable<T> {
public IEnumerable<T> E;
}

public static IParallelEnumerable<T> AsParallel<T> (this IEnumerable<T> self)
{
return new ParallelEnumerable<T> {E = self;}
}

public static IParallelEnumerable<TRet> Map<TArg, TResult> (
this IParallelEnumerable<T> self,
Func<TArg, TRet> f)
{...}
}



The advantage to doing this is that it's trivial to convert between the sequential and parallel versions:


// sequential:
var e = list.Map (v => v);

// Parallel:
var e = list.AsParallel().Map (v => v);


You'd literally only need to add a single method call within the chain to get the parallel version, as opposed to doing a potentially massive symbol rename of s/Map/ParallelMap/g.