heisenbug - Comments

Derek Williams: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Derek Williams) — Mon, 02 May 2011 22:46:20 +0200

Fixed now in Akka. I knew I had compile time type safety with this before, I accidently removed it during a refactoring. Added a test for it now too. If it wasn't for this blog post I wouldn't have tested for it, thanks!

Derek Williams: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Derek Williams) — Mon, 02 May 2011 16:57:22 +0200

Checked again. I did all my testing of type safety within the reset, not with the result. I ignored the value of the reset as it wasn't part of the original spec, just a side effect of the way I implemented it. Values were originally supposed to be returned by assigning values to futures, which is type safe. So it's not really applicable to what you are trying to do here.

Derek Williams: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Derek Williams) — Mon, 02 May 2011 16:41:03 +0200

Nevermind, checked to make sure the right type was infered and it wasn't. Not sure why it works properly in Akka. Maybe I need to test it more, perhaps it isn't doing what I think it is.

Derek Williams: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Derek Williams) — Mon, 02 May 2011 16:34:18 +0200

This works for me: https://gist.github.com/951681

Dr. Roland Kuhn: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Dr. Roland Kuhn) — Mon, 02 May 2011 09:32:13 +0200

Yes, you are right. It seems I was too much caught up in that flatMap scheme to see the easier alternative (and that one can be composed, too). At least it made me research and understand how the continuations plugin can be used, now I can confidently ambush any opportunity for using it

Seriously, though, CPS would for example allow me to keep track of the generators used within one expression. What I also have in my real use case (though based solely on flatMap) is to calculate an estimate of the size of the value set in order to be able to adapt the number of samples taken.

Johannes Rudolph: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Johannes Rudolph) — Mon, 02 May 2011 09:21:08 +0200

The thing is: A generator like you have created here with CPS is much easier created without any CPS at all:

https://gist.github.com/951254

So the question is what the value of using CPS is here. The only line where you are using CPS is here:

Generator( A(genIntA, genBoolA) )

CPS is essentially making the control flow explicit so what you could do behind the scenes here is changing the order in which genInt/genBool are called to produce an A, but why would you want to make use of that here?

rk: Delimited Continuations vs. For-Comprehensions

nospam@example.com (rk) — Mon, 02 May 2011 09:16:46 +0200

I tried, but simply changing it to Generator[Any] did not work and I didn't invest much time in it. What was the exact problem with @suspendable? Making the cps-annotations simpler looks desirable Anyway, will try out more tonight.

rk: Monadic Test Data Generator

nospam@example.com (rk) — Mon, 02 May 2011 09:09:25 +0200

In the end my code leads to the execution of the same commands, this is true, and I started out exactly in the same way as you propose. But then I wanted to combine generators for A's and B's and some primitive types into a generator for C's, which suddenly produced more visual clutter than I liked, so I started thinking and remembered that composition is the one thing monads should be good at, so I tried it.

In my specific use case this approach actually did save some typing and the result looks less confusing.

Derek Williams: Delimited Continuations vs. For-Comprehensions

nospam@example.com (Derek Williams) — Mon, 02 May 2011 05:56:52 +0200

I'm actually not convinced that I do give up type safety with the way I did it. The 'reset' method I have returns the correct type, not a Future[Any]. My first implementation used the '@suspendable' annotation which is the same as @cps[Unit], and I wasn't returning 'Unit'. I only had to change it to get exceptions returned properly.

That being said, making an implementation for a Future is different then something like this so it may not work the same. It might be worth trying it with Generator[Any] and seeing if it does break type safety. You might have to make Generator covariant for that to work.

Good information in there though, I'll have to play around with your code when I get a chance.

Cyril: Monadic Test Data Generator

nospam@example.com (Cyril) — Mon, 02 May 2011 00:15:19 +0200

Hi,

Thanks for the nice article!

I am new to functional programming and I have the following question: why the monadic approach should be preferred to: val someAs = 0 to 10 map ( x => A(Random.nextBoolean, Random.nextInt, Random.nextLong) ) ? This one is much simpler to code/understand/maintain.