Zip Me Up

re: Zip Me Up

Neil — Thu, 01 Apr 2010 10:52:27 GMT

I don't claim to know how iterators work in C#, but the way another language implementation throws an iteration exception when you run off the end of the list allows you to simplify the zip operation something like this:

function zip(left, right) {

for (;;)

yield [left.next(), right.next()];

}

re: Zip Me Up

Greg — Wed, 20 May 2009 01:08:38 GMT

The funny thing is that the code to use the zip join is overly expensive to maintain and develop for in production quality commercial software. The cost is not really in lines of code but in the mental effort needed to understand and verify what is actually happening (easy to verify in a single 10 line chunk but not easy to do when you have 500+ methods using similar coding constructs).

It fails the Monday morning, did not sleep the night before, code takes too long to understand test (even for code you wrote a week ago).

list ret = new list()

int x = max( list1.length, list2.length )

for (int ctr = 0; ctr < x; ctr++)

{

element o1 = o2 = null

if (x < list1.length) o1 = list1[x];

if (x < list2.length) o2 = list2[x];

e = ret.addnew(o1, o2)

}

Concentrating effort on better high level algorithms, data base organization and project organization will yield many times more productivity.

The straight line sequential code is easier to take over and maintain by a developer unfamiliar with the rest of the application's code.

re: Zip Me Up

Daniel Earwicker — Fri, 15 May 2009 01:42:12 GMT

Re: Unfold, thanks! I already wrote my own in a simpler form where the transform part is left out (just stick a Select after it if you need that). I guess everyone using Linq is writing their own slightly different version of it.

re: Zip Me Up

Pop Catalin — Mon, 11 May 2009 12:46:23 GMT

Daniel Lehmann wrote:

> That's exactly the reason why I think Scala made the right decision to put Linq-similar things in libraries and instead create an expandable language. While Linq surely feels nice it can't be extended by anyone except the C# developers...

Linq is a pattern, anyone can adhere to the Linq pattern, which means that the implementation part of Linq is extensible at the core, the only part of Linq that is not extensible is the comprehension syntax (you can't add new comprehension keywords, but you can make the comprehension syntax translate to entirely different "member" calls, usually methods). Other than adding new language keywords, you can extend Linq in any possible way imaginable (you can completely replace Linq to SQL, or Linq to XML, or Linq to Objects with your implementation, or simply mix other implementations with your own selectively)...

The comprehension syntax in linq is simply a loose pattern matching (that works by translating to appropriate "member" calls (not just methods), using regular member resolution rules), the rest of Linq is straight forward libraries with standard CLR types that adhere to the linq pattern, and which can be implemented by anyone.

re: Zip Me Up

Daniel Earwicker — Sun, 10 May 2009 18:11:30 GMT

Eric, will there be an Unfold in version 4?

Not to my knowledge. But it would be trivial to write such a beast yourself. How about this?

static IE<T> Unfold<S, T>(this S state, Func<S, bool> done, Func<S, S> next, Func<S, T> transform)
{
  while (true)
{
    yield return transform(state);
    if (done(state)) yield break;
    state = next(state);
}
}

-- Eric

re: Zip Me Up

Pavel Minaev [MSFT] — Sun, 10 May 2009 10:55:48 GMT

Scala still has syntactic sugar for query comprehensions, no? So it exposes "filter" and "map" already, and in a non-extensible way, too.

Sure, C# goes further than that, with joins and ordering, but fundamentally there's no difference. You still want the common operations to be sugared, the only question is where to draw the dividing line.

re: Zip Me Up

Daniel Lehmann — Sat, 09 May 2009 12:49:59 GMT

"However, we decided that adding a query syntax for a relatively obscure operation that is not actually supported by most relational databases was not worth the cost of complicating the grammar and the syntactic translation rules."

That's exactly the reason why I think Scala made the right decision to put Linq-similar things in libraries and instead create an expandable language. While Linq surely feels nice it can't be extended by anyone except the C# developers...

re: Zip Me Up

Lucas — Sat, 09 May 2009 08:04:28 GMT

Thanks Eric!! I use iterators all the time and was not aware that my null checks (just like in your psychic debugging example) where being deferred... doh!

re: Zip Me Up

Lucas — Sat, 09 May 2009 00:30:28 GMT

Why did you choose a 2-method implementation? What is the need for the private ZipIterator()? Can't you yield return from Zip()?

Good question. I covered that already a while back: http://blogs.msdn.com/ericlippert/archive/tags/Psychic+Debugging/default.aspx

-- Eric

re: Zip Me Up

Ed — Fri, 08 May 2009 23:16:00 GMT

Reviewing what I learned from your excellent post on naming things, I have to admit that Andrey Shchekin's comment is spot on.