March 2009 - Reactive

Re: [reactive] Feedback on my first Reactive program: Monad Laws
by Freddie Manners 30 Mar '09

30 Mar '09

Digging around with the commented query -- that a "pure (string)" is getting delayed -- I've hit a rather fundamental problem: it seems Event doesn't obey the Monad laws. I don't know whether this is a known issue or whether I'm being plain stupid, but this:-- module Main where import FRP.Reactive import FRP.Reactive.LegacyAdapters import Control.Concurrent import Control.Applicative import Control.Monad import Data.Monoid import Data.Maybe main = do clock <- makeClock (sink, evnt) <- makeEvent clock forkIO . sequence_ $ repeat (getLine >>= sink) adaptE . fmap putStrLn $ (pure "A Line!" `mappend` evnt) -- adaptE . fmap putStrLn $ (pure "A Line!" `mappend` (evnt >>= return)) and the same with the penultimate line commented instead of the last, appear to have different behaviours: in the version shown, "A Line!" is printed when the program starts; and in the other, this is delayed until after the first line is read (but before it is printed). Should this happen? Freddie Manners 2009/3/29 Mads Lindstrøm <mads_lindstroem(a)yahoo.dk> > Hi > > As part of studying the Reactive library, I have created a simple game. > The object of the game is to guess a number. > > As I am a newbie with respect to FRP, I assume that my game could have > been implemented more elegantly. Comments are most welcome. > > The game can be found here > http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3037#a3037 and it is > attached. > > > Greetings, > > Mads Lindstrøm > > > _______________________________________________ > Reactive mailing list > Reactive(a)haskell.org > http://www.haskell.org/mailman/listinfo/reactive > >

3 4

Missing key-events and scanlB
by Mads Lindstrøm 29 Mar '09

29 Mar '09

Hi I am trying to make a Behavior, which contains the last pressed key and the distance the mouse traveled since the key was pressed. I programmed this function: charAndRelativeMousePos :: Anim (Maybe (Char, (Double, Double))) charAndRelativeMousePos u = scanlB (\r _ -> r) (pure Nothing) (snapshotWith char (mousePosition u) (keyAction u)) where char (_, Char ch) m = (\newMouse -> Just (ch, newMouse - m)) <$> mousePosition u char _ _ = pure Nothing Unfortunately it is not working. If I move the mouse before pressing a key, then it takes a long time before recognizing the first key-press. And it only recognizes the first key-press, never the second, nor third, ... What am I doing wrong ? I think maybe it has something to do me using "mousePosition u" twice. Am I hanging on to tons of mouse-position, due to the second use of mousePosistion ? A complete program using the charAndRelativeMousePos function can be seen here http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3062#a3062 . Greetings, Mads Lindstrøm

1 0

Feedback on my first Reactive program
by Mads Lindstrøm 29 Mar '09

29 Mar '09

Hi As part of studying the Reactive library, I have created a simple game. The object of the game is to guess a number. As I am a newbie with respect to FRP, I assume that my game could have been implemented more elegantly. Comments are most welcome. The game can be found here http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3037#a3037 and it is attached. Greetings, Mads Lindstrøm

1 0

crayon - a 2D opengl curve renderer, with Reactive animations
by Jules Bean 27 Mar '09

27 Mar '09

Hi, I have just uploaded another little proof-of-concept reactive toy. http://roobarb.jellybean.co.uk/~jules/crayon.8.tgz The important part is the beginnings of an OpenGL accelerated 2D rendering engine, for rendering parametric curves and in particular bezier curves. The way it works at the moment is: * A sampling step tries to adaptively generate points on the curve to approximate it as a polygon. This is done on the CPU, isn't as clever as it could be, but turns out to be not the bottleneck right now * For stroked regions, this is 'thickened' out to a stroke using difference-based approximations to a tangent. This works well for smooth curves but poorly at end points and sharp corners. For filled regions the GLU tessellator is used to convert it to GL primitives, normally triangles. * Then this is rendered by openGL in either immediate mode or using VAs. Currently the sampling and GLU tessellation can be cached and not redone every frame, if the appropriate part of the structure doesn't change each frame. You need to use standard GHC sharing to make this work - define constant picture fragments at a high enough scope that they get shared. The stroke generation is not cached and this turns out to be pretty expensive. You may need to compile with -fno-state-hack to get proper sharing (GHC "issue"/bug). I discovered a bug in the HOpenGL GLU binding. I don't think this demo tickles the bug so it should run on a standard build, details of that bug on the hopengl list. The immediate mode renderer turns out to be faster than the VA based renderer, at least for these small demos. I think that's because the extra pass over the data structure (to generate the VAs) is a relatively high cost, the number of vertices is small, and I'm not smart about sharing vertices. I then plugged all this into Reactive and set up three simple animations - some spinning flowers, some business-like charts, and a classic pong game. You can switch between them using your left + right arrows keys, and they spin in + out using a simple animation, whilst their own animations continue independently. Exactly the kind of thing Reactive is supposed to make easy! The framerate is artificially limited to save battery life when developing. As before, this code uses my incomplete Reactive implementation not Conal's; it should be easy to port although I think some of my primitives have slightly different names. I'm not going to work on this code for a bit, but I have in mind various possible extensions, including using the GPU to do some of the heavy lifting, using a fragment shader to support gradients and other kinds of procedural texturing, supporting implicit curves as well as parametric ones. I'm interested in any thoughts on how to design a useful attractive combinator library for 2D graphics. The real target is to have something fast enough to make an expressive library for complex smooth animations, e.g. 2D games. Jules

7 12

Can we do without delayed switching?
by Patai Gergely 26 Mar '09

26 Mar '09

Hi everyone, I feel this should be very simple to do, but I can't find a way to describe the movement of the ball in a breakout game. What do you think, how should it be modelled? My idea was to define a vector-valued behaviour for the position of the ball, and an event that fires on collisions and carries information about them. I believe such an event is necessary if I am to add sound to the program, for instance, and it feels natural to me anyway. The ball position behaviour is then defined as a stepper in terms of this event. Now the problem is that the event is defined in terms of the ball position among other things. At the moment this leads to a <<loop>>, no matter how I try to approach the problem. This is not too surprising, since I can't really think of a way to define the event other than filtering some kind of clock tick (e.g. framePass) using whenE. Please tell me if there are other, fundamentally different alternatives. After thinking about this for a while, I feel that Reactive really needs delayed semantics for switching, at least optionally. Otherwise I don't see how we could possibly avoid looping, since the event must be generated assuming that the behaviour continues without switching. Such an alternative reality doesn't fit in the semantic domain of time functions, but an infinitesimal delay looks like a possible solution that resolves the dependency loop. Using delayed constructs always felt clumsy in Yampa too, but loops need special attention... Another thought I had for a moment was defining some kind of intermediate semantic domain, where behaviours are represented as a _list_ of time functions (with or without intervals provided), which would somehow give access to pre- and post-switching behaviours (like 'head' and 'tail') through some mid-level combinators. But I don't see how that could be made elegant on the application level, and it doesn't seem to achieve anything the delayed switch can't do for us. What do you think? Gergely -- http://www.fastmail.fm - Access all of your messages and folders wherever you are

6 7

Monads in Event streams
by Freddie Manners 24 Mar '09

24 Mar '09

I've been worrying about what happens when monads end up caught inside an Event stream, as they inevitably do. Usually this is the IO monad, & usually it's not a problem because adaptE deals with Event (IO a) types eventually. But look at the following (contrived) example: I read lots of people's mail. I have a load of buttons which add a person's mail to the set I receive, summarised by: addPerson :: Event Person I want an event of all the mail I get. Given: getMail :: Person -> Event Mail I can do: allMail :: Event Mail allMail = addPerson >>= getMail But realistically, I might have to create a new event for each person, or look the event up in a database or something. Then I have only: getMailM :: Person -> IO (Event Mail) So, fmap getMailM addPerson :: Event (IO (Event Mail)) and there is no longer a function (like "join" above) for getting an Event Mail, an Event (IO Mail), an IO (Event Mail) or even an IO (Event (IO Mail)) out of that as things stand. Given a clock, I could do something like:-- undoIO :: Clock t -> Event (IO a) -> IO (Event a) undoIO c e = do (sink, e') <- makeEvent c forkIO $ adaptE (>>= sink) e return e' But having a clock lying around seems wrong; and I'd ideally like the new Event to be simultaneous with the old one (provided getMailM finishes quickly). I could also do this an old-fashioned way by passing around event sinks; but again that's not really in the spirit. Also, these fixes will only stand a chance with IO (or ST, maybe); what if getMailM :: Person -> State Foo (Event Mail) ? So, can a function be constructed with the desired type (say Event (m (Event a)) -> m (Event a)), or is that unreasonable to expect? Is there a (generalizable) alternative way of doing this example which doesn't require one? This seems a natural thing to want to do. Freddie Manners

3 3

Simple Example ..
by Tom Poliquin 23 Mar '09

23 Mar '09

I've been struggling trying to get a simple Reactive example running .. I'm a newbie to FRP and few months of Haskell (Scheme before that). David Sankel previously posted a simple example which I loaded up with great joy .. but I get the error .. ConsoleAdapter.hs:24:50: Couldn't match expected type `Event Char' against inferred type `FRP.Reactive.Internal.Misc.Sink a' In the first argument of `f', namely `stdinEvent' In the second argument of `fmap', namely `(f stdinEvent)' In the second argument of `forkE', namely `(fmap putChar (f stdinEvent))' Failed, modules loaded: none. I posted the full details up at, http://www.hpaste.org/fastcgi/hpaste.fcgi/view?id=2810#a2810 I also tried the Example.hs (that comes with the 0.10.5 package) but it fails with many errors even after I replaced the import to what I believed was appropriate. ..... --import Reactive.Reactive import FRP.Reactive ........ Examples.hs:72:19: Not in scope: type constructor or class `Reactive' Examples.hs:76:17: Not in scope: `mkEvent' Examples.hs:81:20: Not in scope: `replace' Examples.hs:85:17: Not in scope: `mkEvent' Examples.hs:94:16: Not in scope: type constructor or class `Sink' I know Reactive is in the state of flux so I don't expect things to work without a bit of hacking but a little help would be greatly (!!!) appreciated just to get me started. I've tried wandering the web without success. Thanks, Tom

1 1

Ordering of events in Reactive / Phooey
by Mads Lindstrøm 23 Mar '09

23 Mar '09

Hi If an end-user of a Reactive-based GUI (e.g. Phooey) triggers two events, am I sure that event one will be processed before event two ? (I am assuming that event one occurs before event two) The reason behind this question is: 1) that Reactive uses threads when two event sources are merged - the unambiguous choice function (Unamb.unamb). 2) the scheduler decides when a thread becomes active. So even if an end-user has triggered some event, the scheduler may decide to wait running a thread and thus the processing of the event. >From "Simply efﬁcient functional reactivity" paper I can see that the unamb function should only be called when both arguments will give the same result (not necessarily at the same time). So there should be no problems. And as I understand it, unamb is used to compare min-bound-times with respect to events. Thus the two events will be processed in the right order - I guess. However, this must also mean that events-sources are tagged with min-bound-times - e.g. all event-sources in a GUI, could get the min-bound-time of the latest occurring event. However, looking at the sources for Phooey I cannot see this tagging happening. What am I missing ? When looking at the Phooey and the Reactive code, I could not find the mkEvent function in newer Reactive releases. I therefore also looked at version 0.5, which did not seem to have these bounded time values. This may be the cause of some of my confusion. Greetings, Mads Lindstrøm

2 1

FRP + physics / status of hpysics
by Peter Verswyvelen 11 Mar '09

11 Mar '09

Regarding hpysics, did anybody did some experiments with this? The blog seems to be inactive since december 2008; has development ceased? Do alternatives exist? Maybe good wrappers (hopefully pure...) around existing engines? Integrating hpysics with Grapefruit might be a good topic for the Hackaton, trying to make a simple game (e.g. Pong or Breakout) without using recursive signal functions, but with correct collision response and better-than-Euler integration, all handled by the physics engine. Other FRP engines could be tried, but Grapefruit hacking is already a topic on the Hackaton, so it would combine efforts. It feels as if none of the current FRP engines can handle physics correctly, since a typical physics implementations requires "time backtracking", in the sense that when you want to advance the current simulation time by a timestep, collision events can happen during that time interval, and hence the FRP engine can only advance time until the earliest collision event. So to do physics *with* an FRP engine, the implementation and maybe even semantics of the FRP system might need to be changed. *Using* a physics engine as a blackbox inside an FRP system might make more sense. Thanks to Wolfgang Jeltsch and Christopher Lane Hinson for having a discussion with me that lead to this. Interestingly a similar discussion was help by other people in the Reactive mailing list at the same time :-) Cheers, Peter Verswyvelen

5 13

mappend laziness issue
by Sasha Rush 02 Mar '09

02 Mar '09

I started playing with reactive again and got stuck on a laziness issue with mappend. My codes pretty simple, two events controlled by legacy adapters, one and two. I'm combining them with mappend. both = one `mappend` two For some reason the events get clogged up. So for the first "one" event to fire, a "two" needs to come through, and sometimes vice-versa. It's possible I'm misunderstanding how mappend works, but the docs make it seem that both should fire whenever either fires. Thanks in advance.

1 0