Comments on A Neighborhood of Infinity: Quick and dirty reinversion of control

@anders Keep writing code along those lines and I...

2012-01-19T07:13:29.764-08:00

@anders

Keep writing code along those lines and I wonder if you eventually implement something like iteratees. I haven't thought about iteratees much yet.

Very neat! You can easily "yield for input&q...

2012-01-19T02:15:44.423-08:00

Very neat!

You can easily "yield for input" as well:
https://gist.github.com/1639205

IO already supports linear continuations, but they...

2011-12-10T02:49:49.622-08:00

IO already supports linear continuations, but they aren't necessary here.

yield = do
....mvar <- newEmptyMVar
....idleCallBack $= Just (tryPutMVar mvar () >> return ())
....takeMVar mvar

You can eliminate all the liftIO and ContT stuff, and simply replace runContT with forkIO.

Anonymous, This code avoids IORefs by exploiting ...

2011-11-03T15:35:32.174-07:00

Anonymous,

This code avoids IORefs by exploiting a particular feature of the structure of GLUT applications. Avoiding them in general is a different matter entirely. There are too many different ways to structure Haskell code to give a one size fits all solution.

Barak, Yes, it's a bit crap. At some point so...

2011-11-03T07:23:33.593-07:00

Barak,

Yes, it's a bit crap. At some point someone decided that Float and Double are instances of Enum and had to make up some semantics for a bunch of functions that don't really make sense for Float and Double. It's easy to see why they chose the implementation they did, but I agree it's not good. Some of the bad type class decisions in the standard prelude are getting addressed and I hope this one will be too.

Yeah well they'd be wrong. It violates the ...

2011-11-03T02:39:33.409-07:00

Yeah well they'd be *wrong*. It violates the basic invariant of what an interval means. Note that they were not insane enough to use that logic on integer intervals, because then [0,3..5] would be [0,3,6] but it isn't because that would be crazy.

*Main> [0,3..5]
[0,3]
*Main> [0,3..5.0] -- CRAZY!
[0.0,3.0,6.0]

Here is a simple but painful example. We define piA to approximate pi by naive numeric integration of the area of a 1/4 pie slice of the unit circle.

integrate f x0 x1 dt = dt * sum (map f [x0,x0+dt..x1])

piA dt = 4 * integrate (\x -> sqrt (1 - x^2)) 0 1 dt

*Main> piA 0.0012
3.144014392676234
*Main> piA 0.0011
3.143797733660182
*Main> piA 0.0010
NaN
*Main> piA 0.0009
3.143398824144525
*Main> piA 0.0008
NaN
*Main> piA 0.0007
NaN
*Main> piA 0.0006
NaN
*Main> piA 0.0005
3.142579506573141
*Main> piA 0.0004
3.1423832463242594
*Main> piA 0.0003
3.142195370951823
*Main> piA 0.0002
3.141989327745062
*Main> piA 0.0001
3.141791477784763
*Main> piA 0.00005
3.1416922379085954
*Main> piA 0.00004
NaN
*Main> piA 0.00003
3.1416527395202114
*Main> piA 0.00002
NaN
*Main> piA 0.00001
3.1416126164823903
*Main> piA 0.000009
3.141610659755495
*Main> piA 0.000008
3.141608627038413
*Main> piA 0.000007
3.141606659811757
*Main> piA 0.000006
NaN
*Main> piA 0.000005
NaN
*Main> piA 0.000004
3.1416006441926987
*Main> piA 0.000003
3.1415986563239593
*Main> piA 0.000002
NaN
*Main> piA 0.000001
NaN

Barak, Many would argue that the list [-1, ..., 1...

2011-11-02T11:37:37.431-07:00

Barak,

Many would argue that the list [-1, ..., 1.0000000000000018] is a better approximation to [-1, ..., 1.0] than [-1, ..., 0.9980000000000018]. I recommend avoiding enumFromThenTo with floating point types in production code.

As easy to read as BASIC code perhaps, but when Ha...

2011-11-02T09:55:09.407-07:00

As easy to read as BASIC code perhaps, but when Haskell hits Doubles you may fear for correctness, because in BASIC you won't get this little problem.

Prelude> last [-1, -0.992 .. 1.0]
1.0000000000000018

Hello! You end your post tantalisingly with "...

2011-11-01T19:35:02.343-07:00

Hello! You end your post tantalisingly with "PS Note also that the above code illustrates one way to avoid IORefs in GLUT code." Can this technique be used to avoid IORefs not just in GLUT code but in general, and would you be willing to provide a small example?

Nice! I usually use my operational package for stuff like this, as it makes the implementation of "yield" a single-piece jigsaw puzzle.