netwire

I'm still trying to get a hang of the parallels between arrow notation and the semantics of the Arrow typeclasses defined in Haskell. In particular, this question seems to have a very canonical example of a small counter written with arrow notation: counter :: ArrowCircuit a => a Bool Int counter = proc reset -> do rec output <- returnA -< if reset then 0 else next next <- delay 0 -< output+1 returnA -< output Can someone show me how to convert this back into Haskell2010 without arrow notation? {- | +---------+ >Bool>--------------> | | >------------------>Int> +---------+ | arr f | /---->

I'm getting started with Netwire version 5. I have no problem writing all the wires I want to transform my inputs into my outputs. Now the time has come to write the IO wrapper to tie in my real-world inputs, and I am a bit confused. Am I supposed to create a custom session type for the s parameter of Wire s e m a b and embed my sensor values in there? If so, I have these questions: What's up with the Monoid s context of class (Monoid s, Real t) => HasTime t s | s -> t ? What is it used for? I was thinking of tacking on a Map String Double with my sensor readings, but how should my monoid

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 am trying to create a game using Haskell + Netwire 5 (+ SDL). Now I am working on the output part, where I would like to create wires that read in some game state and output the SDL surfaces to be blitted on screen. However, the problem is that SDL surfaces are contained in IO monad, so any function that creates such surfaces must have type a -> IO b . Of course, arr does not construct a Wire from a -> m b . However, since the type signature of a wire is (Monad m, Monoid e) => Wire s e m a b , it looks quite like a Kleisi Arrow, but I cannot find a suitable constructor for making such a wire