mg.to - Python - Comments

Great work

Sheldon Rampton — Fri, 20 Jun 2008 08:47:04 +0000

Great work on the election maps. Have you seen this?

https://www.electoral-vote.com/

They’re showing an electoral college map of the U.S., which I think will be of intense interest to people now that the primaries are over. Their polling data is available as CSV file downloads, updated daily. It would be neat to see it on Google maps.

Awesome!

Pedro Teixeira — Thu, 24 Apr 2008 02:55:28 +0000

Hi, just watched your talk on youtube and would like to thank you for sharing the great work and experience. The resources are very useful!

ps: the Array.prototype.join.call trick was cool :)

Election Maps

random_anonymous — Wed, 23 Apr 2008 07:28:37 +0000

Your maps are AWESOME! Keep up the great work! :)

Well, yield in ruby surely don't equal to function

femto — Tue, 10 May 2005 19:33:42 +0000

Well, yield in ruby surely don’t equal to function in javascript or delegate in C#. block in ruby is a closure, which means it use the current context where it’s in, it means sth like this:

def fun1 fun2 end def fun2 fun3 { return “hello1”; }

fun3 { return “hello2”; }

end def fun3 yield end result = fun1

puts result #—>”hello1”

###################################3

the first block in fun2 will just return “hello1” to the caller fun1, and skip the second block invocation, but with function pointer or delegate, you sure can’t do this, with return keyword in function pointer or delegate, you just return to where you call the function pointer or delegate.

That’s the differnce between them. the block can decide whether it should return some value to uplevel but function pointer or delegate can’t

Of course, smalltalk does it best with [arg|body] representing a

Anon — Thu, 12 Aug 2004 10:14:01 +0000

Of course, smalltalk does it best with [arg|body] representing anonymous functions. No other language does it better.

Elton, your trackback had an invalid URL:

Michael Geary — Tue, 10 Aug 2004 01:34:40 +0000

Elton, your trackback had an invalid URL:

https://arachnid/Blogs/ewells/archive/2004/08/09/435.aspx

Want to try again?

Elton, your trackback had an invalid URL:

Michael Geary — Tue, 10 Aug 2004 01:32:25 +0000

Elton, your trackback had an invalid URL:

https://arachnid/Blogs/ewells/archive/2004/08/09/435.aspx

Want to try again?

Exploring C# 2.0 iterators

Elton Wells — Mon, 09 Aug 2004 21:20:02 +0000

Exploring C# 2.0 iterators

Exploring C# 2.0 iterators

Elton Wells — Mon, 09 Aug 2004 21:20:01 +0000

Exploring C# 2.0 iterators

I'm a Ruby fan too

Another Tired Idea — Fri, 06 Aug 2004 01:08:23 +0000

I’m a Ruby fan too

argh. sorry about this. it doesn't seem to like unescaped <s.

mike roome — Tue, 03 Aug 2004 12:52:17 +0000

argh. sorry about this. it doesn’t seem to like unescaped <s… and again, this time without the huge, and now utterly redundant comment: using System; class C { public static void MyIterator(Action yield) { Console.WriteLine("Before First"); yield("First"); Console.WriteLine("After First"); for(int i = 0; i < 3; i++) yield(i.ToString()); Console.WriteLine("Before Last"); yield("Last"); Console.WriteLine("After Last"); } public static void Main() { MyIterator(delegate(string s) { Console.WriteLine(s); }); } }

damnit. my code got mangled...

mike roome — Tue, 03 Aug 2004 12:48:58 +0000

The ruby example isn't exactly equivalent, from what i understan

mike roome — Tue, 03 Aug 2004 12:46:57 +0000

The ruby example isn’t exactly equivalent, from what i understand of ruby — a block defines an anonymous function, which is passed into the method being called, and can be called within the function with ‘yield’. The end result is more or less the same, but the method by which the result is achieved is completely different.

For what it’s worth, you could semantically equivalent to the ruby example in C# as well, using anonymous delegates:

using System;

class C {

/**

* delegate void Action<t>(T obj); is a standard delegate provided by the

* 2.0 class library. Others include:

* bool Predicate<t>(T obj);

* U Converter<t ,U>(T from);

* int Comparison<t>(T x, T y);

* see https://blogs.msdn.com/kcwalina/archive/2004/06/22/162533.aspx

* for more details

* also, since 'yield' isn't a keyword on its own (it's only special in a

* 'yield return' or 'yield break' statement), i decided to call the

* delegate 'yield', to make the correspondence to the ruby clearer.

**/

public static void MyIterator(Action<string> yield) {

Console.WriteLine("Before First");

yield("First");

Console.WriteLine("After First");

for(int i = 0; i < 3; i++) yield(i.ToString());

Console.WriteLine("Before Last");

yield("Last");

Console.WriteLine("After Last");

}

public static void Main() {

MyIterator(delegate(string s) {

Console.WriteLine(s);

});

}

using System;

    for(int i = 0; i < 3; i++) yield(i.ToString());

    Console.WriteLine("Before Last");
    yield("Last");
    Console.WriteLine("After Last");
}

public static void Main() {
    MyIterator(delegate(string s) {
        Console.WriteLine(s);
    });
}

}

(note: i haven’t tested this, but it should work on Beta1, afaik).

Let's iterate over this topic one more time

Another Tired Idea — Tue, 03 Aug 2004 10:33:03 +0000

Let’s iterate over this topic one more time

Michael Geary returns

Under The Hood - Matt Pietrek — Tue, 03 Aug 2004 09:02:52 +0000

Michael Geary returns