reactive-banana

I am learning reactive-banana. In order to understand the library I have decide to implement a dummy application that would increase a counter whenever someone pushes a button. The UI library I am using is Gtk but that is not relevant for the explanation. Here is the very simple implementation that I have come up with: import Graphics.UI.Gtk import Reactive.Banana import Reactive.Banana.Frameworks makeNetworkDescription addEvent = do eClick <- fromAddHandler addEvent reactimate $ (putStrLn . show) <$> (accumE 0 ((+1) <$ eClick)) main :: IO () main = do (addHandler, fireEvent) <- newAddHandler

I have scoured the documentation of reactive-banana , and I can't find a way to specify explicit time delays. Say, for example, I would like to take an Event t a and shift all of its occurrences 1 second into the future; or get an event that fires 1 second from now (within Moment t ); or anything like that. Are explicit delays representable in reactive-banana? If not, how do users implement, e.g., echoing input delayed by a second? As Ben indicates, this is correct: reactive-banana is no built-in notion of time and delays. The main reason is that it is hard to guarantee that logical time and

I've been comparing pull-only FRP (ie netwire) with push-pull FRP (ie reactive-bannana) in the implementation of games. Are there advantages to one over the other? Things I've notices are: Push events make it easy to have events for mouse clicks / key presses from GLFW or GLUT Arrowized FRP that netwire uses has much less IO floating around, which is always better. It looks like having pull-only responses to things like mouse movement could cause time leaks. What else have I missed? Edit, to make this less opinion-based: The main goal is to have something that is as expressive/concise as

In a previous SO question ( Is it possible?: Behavior t [Behavior t a] -> Behavior t [a] ) we were analyzing the existence of a Behavior join (to use reactive-banana terms). Behavior t (Behavior t a) -> Behavior t a Implemented in the semantic model as follows type Behavior t a = t -> a behaviorNow :: Behavior t (Behavior t a) -> Behavior t a behaviorNow f t = f t t While implementing this directly would be unfortunate since we could produce a Behavior Monad using const and behaviorNow , if and how does behaviorNow violate the semantics of FRP? I'd love to hear answers using the terminology of

I found the reactive-banana-wx and wonder if there is also a similiar package for gtk as reactive banana should support gtk according to http://www.haskell.org/haskellwiki/Reactive-banana The reactive-banana library can be used on top of any imperative event-based library via the AddHandler type. However, it is often convenient to write a little glue code that is specific to the library you want to build on. This is what reactive-banana-wx does for the wx library. I have trouble installing GTK on my Mac, that's why I haven't written a similar glue code package for the gtk library. However,