- Haskell-Cafe - Haskell.org

Yesod 1.0 Release Candidate
by Michael Snoyman 05 Apr '12

05 Apr '12

Hi everyone, I'd like to announce the availability of the Yesod 1.0 release candidate. The code is available on Hackage now, so you should be able to install with a simple `cabal update && cabal install yesod` to get up-and-running. If you've been installing from Github or Yackage, you'll probably have the smoothest ride by wiping out your ~/.ghc and ~/.cabal/packages/cabal-src folders, and disabling Yackage as a remote repo in ~/.cabal/config. We're setting a release date of next Monday, April 9. That's when we'll be posting an official release announcement and releasing a new version of yesod-platform. At this point, the code is well tested and usable (in fact, it *is* in production use on multiple sites), but we wanted to give everyone one last chance to hammer away at the code. One of the goals with this release is to try to start pushing Haskell and Yesod to the masses (i.e., we're going to fail to avoid success at all costs). We're going to be trying to demonstrate the advantages Haskell provides over other solutions out there. I think this is the kind of effort that we can all work on together as a community. If anyone's interested in helping out with promoting, please be in touch. Michael

1 0

lhs2TeX: automatic line wrap within code blocks?
by david.mihola 05 Apr '12

05 Apr '12

Hello, I am currently using lhs2TeX for the first time and have encountered a problem which I am unable to solve myself: Some code lines are too long to fit into a single line of the output (PDF) file and thus go off the right edge of the page. Consider the following example: ------------------------------------- \documentclass{article} \usepackage[utf8]{inputenc} %include polycode.fmt %options ghci \begin{document} Our encrypted message: \begin{code} cyphertext = "rlkmlj, zlnift ekblvke pqc elvm if pzlp gblrk, akrlomk zk zle lfpiriglpke pzlp, if pzk flpojlb rcojmk cs knkfpm, morz qcobe ak pzk rcfeorp cs nkjriftkpcjiu, bklnkm pzk ljdv ofekj gjkpkfmk cs jlimift jkrjoipm lfe rlnlbjv" \end{code} Our decryption function: \begin{code} decrypt = id \end{code} The original message was: \eval{decrypt cyphertext} \end{document} ------------------------------------- Converting this to .tex with lhs2TeX and to .pdf with pdflatex produces a PDF in which both instances of the cyphertext go off the right edge of the page. Is there any way to tell lhs2TeX to allow/force line wrap within code blocks and eval-statements? Thank you very much for any help! David P.S.: I have only found one prior discussion of my question (http://tex.stackexchange.com/questions/15048/how-to-typeset-a-multiline-tex…) but to my understanding no real answer came out of that. -- View this message in context: http://haskell.1045720.n5.nabble.com/lhs2TeX-automatic-line-wrap-within-cod… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 2

thread killed
by tsuraan 05 Apr '12

05 Apr '12

What sorts of things can cause a thread to get an asynchronous "thread killed" exception? I've been seeing rare, inexplicable "thread killed" messages in my Snap handlers for a long time, but they aren't from Snap's timeout code. I recently upgraded to ghc 7.4.1, and that caused the kills to happen a lot more often, but also gave me some traceback capabilities. I tracked the most common kills down to cryptohash's Crypto.Hash.Tiger.update function, but that's about as pure a FFI function can be, so I don't know how that would be causing anything weird to happen. I also sometimes get the kills in the Tiger.finalize function, and I get other ones in functions that I haven't been able to track down yet. Given that the thread kills aren't from Snap's timeout code (they happen in under a second, and I have snap's timeouts turned to an insanely high value), what sort of other things cause ThreadKilled exceptions? Thanks for any help; this is really driving me mad :-/

4 9

Haskell Weekly News: Issue 221
by Daniel Santa Cruz 05 Apr '12

05 Apr '12

Welcome to issue 221 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of March 25 to 31, 2012. Quotes of the Week * Tekmo: Now I have a monoid in the category of problems. * hpc: atomically the whole thing * BMeph (in "announcer voice"): In a world, where orphan instances collide, one language holds the key to successful compilation, in our time. * thoughtpolice: if there is a question, edwardk probably has the answer * danharaj: All I have to do is remove me from the program and it works. * anonymous: Caveat implementor. * ski: 'getLine :: IO String' is a recipe for how to interact with the world to acquire a `String' ski: the recipe is not the cake Top Reddit Stories * My Thesis is Finally Complete! "Elm: Concurrent FRP for functional GUIs" Domain: self.haskell, Score: 74, Comments: 31 On Reddit: [1] http://goo.gl/yw2P9 Original: [2] http://goo.gl/yw2P9 * ANNOUNCE: Happstack 7! (Haskell Web Framework) Domain: happstack.com, Score: 51, Comments: 26 On Reddit: [3] http://goo.gl/kwcc7 Original: [4] http://goo.gl/wBBsu * pipes-like conduit Domain: yesodweb.com, Score: 49, Comments: 84 On Reddit: [5] http://goo.gl/nu4Tl Original: [6] http://goo.gl/hWaCj * SIMD Support for the vector library Domain: ghc-simd.blogspot.co.uk, Score: 45, Comments: 6 On Reddit: [7] http://goo.gl/m0PI8 Original: [8] http://goo.gl/NDq2j * Replacing Cabal Domain: yesodweb.com, Score: 40, Comments: 7 On Reddit: [9] http://goo.gl/ulv2o Original: [10] http://goo.gl/86NLW * Summarizing the conduit questions Domain: yesodweb.com, Score: 33, Comments: 13 On Reddit: [11] http://goo.gl/lkLgF Original: [12] http://goo.gl/uK25n * I love `RWST r w s (IO a) ` to ease the transition from imperative programming. Am I cheating? Domain: self.haskell, Score: 31, Comments: 53 On Reddit: [13] http://goo.gl/xq2Jn Original: [14] http://goo.gl/xq2Jn * FRP - Three principles for bidirectional GUI elements Domain: apfelmus.nfshost.com, Score: 30, Comments: 11 On Reddit: [15] http://goo.gl/AFbXE Original: [16] http://goo.gl/xd4Yf * haskell-src-exts-1.12.0: supports the new quasi-quoter syntax Domain: haskell.org, Score: 28, Comments: 6 On Reddit: [17] http://goo.gl/u6ZDx Original: [18] http://goo.gl/XTzJO * Why GADTs are awesome: implementing System F using HOAS Domain: github.com, Score: 25, Comments: 7 On Reddit: [19] http://goo.gl/IG14P Original: [20] http://goo.gl/62iLX * Reactive-banana: new major release Domain: apfelmus.nfshost.com, Score: 24, Comments: 3 On Reddit: [21] http://goo.gl/XYXvm Original: [22] http://goo.gl/u3PAz Top StackOverflow Questions * Does Haskell require a garbage collector? votes: 40, answers: 7 Read on SO: [23] http://goo.gl/hDNT4 * Can you recognize an infinite list in a Haskell program? [closed] votes: 20, answers: 5 Read on SO: [24] http://goo.gl/TcJHt * Confusion regarding a passage in the “Kinds and some type-foo” section of learnyouahaskell.com votes: 12, answers: 1 Read on SO: [25] http://goo.gl/ldKbM * Haskell: Correct practice to specify version in source? votes: 7, answers: 2 Read on SO: [26] http://goo.gl/eUr6X * How to count the number of times a fuction was called, the FP way votes: 7, answers: 2 Read on SO: [27] http://goo.gl/OLNxy * how to translate Haskell into Scalaz? votes: 7, answers: 2 Read on SO: [28] http://goo.gl/1ep62 * In which languages is function abstraction not primitive votes: 7, answers: 7 Read on SO: [29] http://goo.gl/aZG5w * Is it possible to debug pattern matching in a Haskell function? votes: 6, answers: 3 Read on SO: [30] http://goo.gl/qIpDw * Generate cabal file with dependencies on foreign libs votes: 5, answers: 2 Read on SO: [31] http://goo.gl/mRz1o * Is there a monadic version of Arbitrary to use with QuickCheck? votes: 5, answers: 2 Read on SO: [32] http://goo.gl/1IOg4 Until next time, Daniel Santa Cruz References 1. http://www.reddit.com/r/haskell/comments/rkyoa/my_thesis_is_finally_complet… 2. http://www.reddit.com/r/haskell/comments/rkyoa/my_thesis_is_finally_complet… 3. http://www.happstack.com/C/ViewPage/1 4. http://www.reddit.com/r/haskell/comments/rjtwt/announce_happstack_7_haskell… 5. http://www.yesodweb.com/blog/2012/03/pipes-like-conduit 6. http://www.reddit.com/r/haskell/comments/reft1/pipeslike_conduit/ 7. http://ghc-simd.blogspot.co.uk/2012/03/simd-support-for-vector-library.html 8. http://www.reddit.com/r/haskell/comments/reyn9/simd_support_for_the_vector_… 9. http://www.yesodweb.com/blog/2012/04/replacing-cabal 10. http://www.reddit.com/r/haskell/comments/rnd2b/replacing_cabal/ 11. http://www.yesodweb.com/blog/2012/03/summarizing-conduit-questions 12. http://www.reddit.com/r/haskell/comments/rhs0y/summarizing_the_conduit_ques… 13. http://www.reddit.com/r/haskell/comments/rd2t5/i_love_rwst_r_w_s_io_a_to_ea… 14. http://www.reddit.com/r/haskell/comments/rd2t5/i_love_rwst_r_w_s_io_a_to_ea… 15. http://apfelmus.nfshost.com/blog/2012/03/29-frp-three-principles-bidirectio… 16. http://www.reddit.com/r/haskell/comments/rj4l1/frp_three_principles_for_bid… 17. http://www.haskell.org/pipermail/haskell-cafe/2012-March/100421.html 18. http://www.reddit.com/r/haskell/comments/rfn3g/haskellsrcexts1120_supports_… 19. https://github.com/DanBurton/Blog/blob/master/Literate%20Haskell/SystemF.lhs 20. http://www.reddit.com/r/haskell/comments/rk0uf/why_gadts_are_awesome_implem… 21. http://apfelmus.nfshost.com/blog/2012/03/25-frp-banana-0-5.html 22. http://www.reddit.com/r/haskell/comments/rd35t/reactivebanana_new_major_rel… 23. http://stackoverflow.com/questions/9952602/does-haskell-require-a-garbage-c… 24. http://stackoverflow.com/questions/9889347/can-you-recognize-an-infinite-li… 25. http://stackoverflow.com/questions/9892814/confusion-regarding-a-passage-in… 26. http://stackoverflow.com/questions/9857710/haskell-correct-practice-to-spec… 27. http://stackoverflow.com/questions/9920129/how-to-count-the-number-of-times… 28. http://stackoverflow.com/questions/9941199/how-to-translate-haskell-into-sc… 29. http://stackoverflow.com/questions/9944159/in-which-languages-is-function-a… 30. http://stackoverflow.com/questions/9949494/is-it-possible-to-debug-pattern-… 31. http://stackoverflow.com/questions/9857597/generate-cabal-file-with-depende… 32. http://stackoverflow.com/questions/9863451/is-there-a-monadic-version-of-ar…

1 0

Is this a correct explanation of FRP?
by Peter Minten 04 Apr '12

04 Apr '12

Hi, I've been trying to get my head around Functional Reactive Programming by writing a basic explanation of it, following the logic that explaining something is the best way to understand it. Am I on the right track with this explanation? Greetings, Peter Minten P.S. Sorry about the long mail, the explanation ended up a little longer than I originally expected. :) Document (with markdown formatting) follows: --8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<-- This is an attempt to explain Functional Reactive Programming (FRP) enough to give a reader with no previous exposure to FRP an intuition what FRP is about. After reading this you should hopefully understand enough of FRP to understand the [reactive-banana](http://www.haskell.org/haskellwiki/Reactive-banana) examples. FRP has certain terms such as behavior, event and time-varying that can be confusing for people unfamiliar with it. I'll avoid these terms at first and will focus on spreadsheets and a generalization of spreadsheet cells (which I will call boxes). Later, once the most important concepts are explained, reactive-banana syntax will be introduced along with an example that demonstrates how to work with behaviors and events in reactive-banana. Finally some theory about time-varying functions and how events and behaviors can be implemented using pure functions by making time explicit should provide the necessary background to understand reactive-banana's haddock comments. The version of reactive-banana used here is [0.5.0.0](http://hackage.haskell.org/package/reactive-banana-0.5.0.0). Reactive Programming for the Masses: The Spreadsheet ==================================================== Spreadsheets are something we all (for certain values of we) know about. Let's talk about a typical, simplified, spreadsheet. We have a list of products that we sell and want to compute their price with the Value Added Tax (VAT) added. We might have cells A1 to A10 contain the raw prices of our products and cell B1 contain the current VAT rate (say 19 for a 19% VAT). In cells C1 to C10 we'd like to see the prices including VAT. In cell C1 we'd have a formula: `=A1*(1+B1/100)`, in cell C2 `=A2*(1+B1/100)`, etc. So if A1 contains $100 C1 would contain $119. But what if the government, in it's eternal quest to reduce the budget deficit, raises the VAT rate? We'd adjust cell B1, just change it to 20. And like magic all the C cells are updated. Though this may seem mundane what we've just seen is actually a very good example of reactive programming. We didn't tell the C cells to update; they updated on their own because a value they depend on changed. >From Cells to Boxes: Generalizing the Spreadsheet ================================================= Spreadsheets are nice, but if we want to truly get a feel for FRP we'll have to think beyond them. If we look at a spreadsheet at an abstract level it pretty much consists of cells of two types: value cells (`19`) and formula cells (`=A1*(1+B1/100)`). Let's lose the reference to spreadsheets and talk about boxes. Say, for now, that there are two kinds of boxes: formula boxes and value boxes. Both support a "get" operation that returns a value. Value boxes additionally support a "set" operation that sets the value. Formula boxes can contain any kind of pure function. They can also refer to the values of other boxes (both formula and value boxes). Value boxes don't have a function inside them, they have a value. The translation of our VAT spreadsheet would be something like a formula box *fIncl1* containing the expression `get(vExcl1) * (1 + get(vVat) / 100)`. This expression uses two value boxes: *vExcl1* and *vVat*. We could also write *fIncl1* using a helper formula box *fVat*. Let *fVat* have the formula `1 + get(vVat) / 100` and *fIncl1* have the formula `get(vExcl1) * get(vVat)`. I'll use `:=` for this kind of definition, the `:=` is there to remind you that this isn't Haskell. It's important to note that any kind of value may be put into value boxes, including IO actions and functions. Try doing this with a spreadsheet: `fIncls := [get(ve) * get(vVat) | ve <- vExcls]`. Or this: `fIncl1 := apply(get(vVatFunc), get(vExcl1))`. If you're wondering why I'm not using Haskell syntax, it's to focus on the meaning of boxes rather than what the functions and combinators mean. That said, this pseudo-imperative syntax is on its way out as it's getting too clunky (that `apply` function is really just ugly). For a quick peek ahead the last few examples would be something like this in reactive-banana: fIncls = map (\ve -> (*) <$> ve <*> fVat) vExcls fIncl1 = fVatFunc <*> vExcl1 Events ====== Let's say we want to build the worlds worst synthesizer. We have 7 buttons: "a", "b", "c", "d", "e", "f" and "g". Our output is generated by sampling a box twice per second and playing the frequency in the box until the next sample is taken. This can't be expressed with the crude formula and value boxes system we've had so far. There is no way to express key presses in that system, a key press isn't like changing a value, it's something that occurs on a specific point in time but after it occurs it's forgotten (your keyboard doesn't remember key strokes, at least mine doesn't). In this new system we'll forget about formula boxes and value boxes and introduce event boxes. Event boxes are like formula boxes in that they can refer to the value of other boxes. Event boxes can also react to events. Events can be thought of like signals in something like D-Bus. Multiple things (event boxes) can listen to them and do something once a specific event is fired (triggered). Every event has a value associated with it. Sometimes the value isn't important because the fact that the event has occurred is what's interesting but often we do want to know the value. Events come in streams. When we say event box *b1* changes to the value of event *e1* when it receives that event we're actually saying that whenever an event from the stream of events we colloquially call *e1* comes *b1* changes to the value of that event. Yes, that's confusing so I'll try to be precise. Just remember that when I refer to something like *e1* when defining an event box it's always to a stream of events, never a specific event. If you're puzzled by the stream just think of it as an acknowledgement that a certain kind of event can occur multiple times. It actually goes a lot deeper than that, involving those confusing `[(t, e)]` types, but for now just remembering that a kind of event can occur multiple times with possibly different values is good enough. Events have values and we can use that to chose to do something only for events with some value. So not only can we determine which streams of events we'll do something with when defining an event box, we can also determine for what values of events we'll do something. For example if we have an event that directly sets our synthesizer frequency we can apply a filter that only allows events with frequencies that are pleasant to the human ear. Some Reactive-Banana syntax =========================== Expressing event handling with the pseudo-code I've used before is tricky and gets near impossible soon. So it's a good thing that once you've understood or at least got a basic idea of the concepts of event streams and event boxes the syntax of reactive-banana starts to make sense. In this section I'll explain the most fundamental functions and operators. If you're reading the [reactive-banana 0.5 haddocks](http://hackage.haskell.org/package/reactive-banana-0.5.0.0) there are a few things to keep in mind. The first is that what I've called an event box in the previous section is called a Behaviour in reactive-banana. To avoid confusion I'll stop using the term event box from here on. In the reactive-banana haddocks you'll find a lot of references to time-varying functions and lists involving time variables. Just ignore those, they're important but we'll get to them later. As a general rule just ignore what you don't understand. You'll also notice a `t` parameter on the `Event` and `Behavior` types. It's basically similar to the `s` parameter for `STRef`, it's a trick to use the type system to prevent constructs that would result in undefined or incorrect behavior. Just ignore it. For understanding the next sections you'll need to know about a basic subset of reactive-banana which I'll explain here. First up: event streams. Events ------ Event streams are represented by the type Event in reactive-banana. The type `Event t Int` means a stream of events carrying Int values. There are three basic things you can do with just event streams. You can transform the events in them, you can filter in events in them and you can combine the event streams. Transforming an event stream means changing the values carried by the events in them. As this is *Functional* Reactive Programming the streams themselves are not changed. When you transform a stream you create a new stream. Whenever an event in the old stream is fired an event in the new stream is also fired, but with a different value. Transforming an event stream is done primarily by good old fmap. The expression ``show `fmap` eInt`` (or with the (`<$>`) operator `show <$> eInts`) with *eInt* having the type `Event t Int` creates a new event stream of the type `Event String` with the int in every event in the original stream being a string in the new stream. To replace the value of an event (if the event doesn't carry a useful value) just use (`<$`): `"MOO!" <$ eWhatever` causes every value in the stream eWhatever to be replaced by MOO!. Like (`<$>`) this is an operator from Control.Applicative. Filtering is done using the `filterE` function. When you filter an event stream you create a new event stream with the same associated values but which doesn't contain all the events from the original stream. To only deal with events with positive integers you can create a filtered stream using ``filterE (>= 0) eInt``. Combining event streams creates a new event stream with all the events from both streams. So if you combine *eOne* and *eTwo* into *eThree* there will be an event in *eThree* for every event in *eOne* and for every event in *eTwo*. Combining is done with the union function: ``eThree = eOne `union` eTwo``. Beware however that when events come in at the same time things can get a little tricky, you'd have to wonder in what order the events are processed. Reactive-banana contains several functions to handle simultaneous events. For the purpose of this document we'll do the easiest thing and ignore simultaneous events. In real world code you would need to think about it. Behaviors --------- To create a behavior (event box) in reactive-banana you'll typically use one of two functions: `stepper` and `accumB`. Both work with an initial value and an event stream. The difference is that when an event occurs `stepper` changes the value of the behavior to the value in the event while `accumB` applies the function in the event to the value of the behavior. eNewVal :: Event t Int bSet :: Behavior t Int bSet = stepper 0 eNewVal eUpdater :: Event t (Int -> Int) bUpdated :: Behavior t Int bUpdated = accumB 0 eUpdater The expression `bSet = stepper 0 eNewVal` creates a behavior named *bSet* with initially value 0. Once an event from the *eNewVal* stream comes in the value of *bInt* changes to the value in that event. So if an event comes in with value 2 the value of bSet becomes 2. On the other hand the expression `bUpdated = accumB 0 eUpdater` makes *bUpdated* a behavior with initially the value 0 but which gets updated (modified) whenever an event comes in. If an event comes in with value (+1) (a slice, so `\x -> x + 1`) and the current value of *bUpdated* is 1 the new value becomes 2. That's basically it for behaviors. Well, there's a third way to create behaviors: using `pure`. To create a behavior with the value 1 which doesn't change at all use `pure 1`. In case you didn't know, for applicative functors (which behaviors are) `pure` is what `return` is for monads. To create a behavior that's depends on old behaviors (`f3 := get(f1) + get(f2)` in our old formula box syntax) we have to use applicative functor functions in reactive-banana. There is unfortunately no option to use monad syntax. To express that the value of *b3* is the sum of the value of *b1* and the value of *b2* we write: `b3 = (+) <$> b1 <*> b2`. Example: The Worlds Worst Synthesizer ===================================== Now for an example. We'd like to create a synthesizer. The synthesizer will use our keyboard for input, which we notice through a stream of events called *eKey* with as associated value a Char containing the key that was pressed. Something outside our program (and scope of discussion) samples the behavior *bNote* every 100ms and plays the tone currently in there until the next sample time. To avoid getting caught up in music theory (read: I'm lazy and can't be bothered to look up tone frequencies) the note to play is expressed as an algebraic data type. type Octave = Int data Pitch = PA | PB | PC | PD | PE | PF | PG data Note = Note Octave Pitch -- Type signature for the key event, it comes from outside our -- system. eKey :: Event t Char You'll notice the octave. To change the octave we'll use the '-' and '+' keys. To set the pitch we'll use the 'a'..'g' keys on the keyboard. Never mind that it's really annoying to play with those keys as they're scattered all over the keyboard, this is about the FRP logic not practicality. Those chars in the *eKey* event stream need to be translated to pitches. Here's one way to do that. ePitch :: Event t Pitch ePitch = (PA <$ filterE (=='a') eKey) `union` (PB <$ filterE (=='b') eKey) `union` ... (PG <$ filterE (=='g') eKey) The "trouble" here is that we're filtering the stream multiple times, not very efficient. Here's a better way. table = [('a', PA), ('b', PB), ..., ('g', PG)] ePitch = filterJust $ (\e -> lookup e table) <$> eKey The `filterJust` function is a simple helper in reactive-banana. It filters out `Nothing` events and returns the value inside the `Just` constructor for `Just` events. To get *ePitch* we first look up the characters in the translation table and then remove all events who's chars aren't in the table, removing the `Just` wrapper from events who's chars are in the table at the same time. The *bNote* behavior will not use these events directly, instead *bOctave* and *bPitch* will each store part of the note and *bNote* will combine the information. eOctUp, eOctDown :: Event t Char eOctUp = filterE (=='+') eKey eOctDown = filterE (=='-') eKey bOctave :: Behavior t Octave bOctave = accumB 0 $ ((+1) <$ eOctUp) `union` ((subtract 1) <$ eOctDown) bPitch :: Behavior t Pitch bPitch = stepper PC ePitch bNote :: Behavior t Note bNote = Note <$> bOctave <*> bPitch If you understand what's going on here you should have a basic idea of what FRP is in practice. There are of course considerations in the real world that we've skipped over here, such as how to get the keyboard event and how to play the sounds. To get a better idea of what FRP in the real world looks take a look at the [reactive-banana examples](http://www.haskell.org/haskellwiki/Reactive-banana/Examples), they should be easy to follow. When following those examples you'll come across the (`<@`) and (`<@>`) operators. I'll give a short introduction here to make it easier to understand the examples. The (`<@`) operator is used like this: `e2 = b1 <@ e1`, if an event in stream *e1* comes in the value of that event is replaced in the *e2* stream by whatever value is in *b1* at the time. The (`<@>`) operator is used in much the same way, but it doesn't replace the value from *e1* outright but uses it to compute a new value. bOne :: Behavior t Int bOne = pure 1 bPlusOne :: Behavior t (Int -> Int) bPlusOne = pure (+1) eAlwaysOne, ePlusOne :: Event t Int eAlwaysOne = bOne <@ eWhatever ePlusOne = bPlusOne <@> eInt Time-varying values and functions ================================= If you've read about FRP before you're likely to have come across the term "time-varying function". This sounds difficult, but once you understand the basics of behaviors and events it's really no big deal. Here's the clue: a behavior contains a value, but the value can change. Therefore at different points in time a behavior can have different values. So we could say that a behavior has a value that varies in time. We could also throw away the concept of boxes and say a behavior *is* a value that varies in time. This is more correct, those boxes are helpful as teaching concepts but once we talk directly about time they are no longer needed. So, a time-varying value is simply a behavior as behaviors can have different values at different points in time. A time-varying function is also just a behavior, one where the value is a function (functional programming 101: the clue to every riddle is that functions are values). To go further down the rabbit hole a time-varying value can actually be thought of as a function by making time explicit. If a behavior has value 1 up to the 30th's second and from that point forward value 2 we could express the behavior as: `\t -> if t < 30 then 1 else 2`. This is important: by making time explicit we can reason about behaviors as if they were pure functions. While in practice we're dealing with applicative functors (or in other libraries monads or arrows) we can think of behaviors as pure functions. Real world behaviors aren't as simple as from 30 seconds onwards change to value 2. They interact with events. So to express such behaviors as pure functions events need to be expressed in a way that works for pure functions. This is where the `[(t,e)]` type comes in. We can see events as a list of values at certain points in time, for example `[(10, 1), (20, 2), (30, 3)]` for events that occur on second 10, 20 and 30 with values 1, 2 and 3 respectively. When viewing events in such a way it becomes easy to create a behavior that changes to whatever value was last: type Time = Int stepped :: [(Time, Int)] -> Time -> Int stepped es t = case takeWhile (\(t', _) -> t' <= t) es of [] -> 0 xs -> snd (last xs) For once this is actually runnable code. If we invoke it as `stepped [(10,1),(20,1),(30,1)] 2` the result is 0, if we invoke it as `stepped [(10,1),(20,1),(30,1)] 12` the result is 1, as expected. Stepped sounds a lot like stepper and we can create that function by making a few small adjustments. type Time = Int stepper :: a -> [(Time, a)] -> (Time -> a) stepper d es = \t -> case takeWhile (\(t', _) -> t' <= t) es of [] -> d xs -> snd (last xs) If you understand this bit, why behaviors and events can be expressed by making time explicit you have a good intuition of what FRP is. Good luck on your endeavors in FRP land.

6 12

GSOC Proposal 2012 : HDBC
by pranjal pandit 04 Apr '12

04 Apr '12

Hi, I would like to work on improving the HDBC as a GSOC project 2012. I have a previous working experience with Django and its ORM and I had a look at Amnesia (http://amnesia.sourceforge.net/user_manual/manual.html) which is a SQL database interface for Erlang. Few of the features of both include: 1 ) Database operation are supported through Language Native types. 2 ) Direct table creation from native language constructs. (models.py in Django and *tablename*.hrl in Amnesia) I would like to make developement in HDBC so that all Database interactions are made through Haskell Native data type. For eg - In using Erlang Database interface through Amnesia on would write (Quoting example from Amnesia Documentation) populate() -> {ok, Pid} = amnesia:open(sales), %% adding customer {ok, Cust1} = amnesia:add_new (Pid, #customer {customer_code = 102341, name = "John", address = "XXXXX", email = "john@xxx"}), %% adding product {ok, P1} = amnesia:add_new (Pid, #product { product_code = "001", description = "CPU Intel", price = 231.10 }), %% now let's add an order for customer "Cust2" {ok, Order} = amnesia:add_new (Pid, #orders { order_number = 30, order_date = {2008, 7, 17}, customer = Cust1 }), Here each Erlang record (#customer, #product and #orders) are responsible for different Database Tables. So writing the first statement inserts into database and return an object Cust1 that can be used late down the line to create an order table object. In Django through Python one would have written: customer = Customer.objects.create(customer_code=102341, name = "John", address = "XXXXX", email = "john@xxx" ) order = Orders.objects.create(order_number = 30, order_date = {2008, 7, 17}, customer = customer) Writing everything through Language type increases more readability inside the code. Additionally this helps in abstracting the logic in code from the underlying SQL being executed. In addition to the support for select, insert, update queries the my work would extend support for Joins, aggregations etc all in Haskell Native Types. I would also like to work to handle the database queries from wire formats/ binaries instead of strings as is the case currently. I would like to close down these two features as a GSOC project during the summer of 2012 and I would your feedback on the same. -- Regards Pranjal Pandit Don't communicate by sharing memory; share memory by communicating.

3 2

Conduits: Is Source a valid instance of Monad?
by Aristid Breitkreuz 04 Apr '12

04 Apr '12

Hi all, As you may have noticed, Michael Snoyman has been working on an alternative approach to I/O, called conduits. You can find it here: https://github.com/snoyberg/conduit When looking at the Source type (explained here: http://www.yesodweb.com/blog/2011/12/conduits) I noticed that they seem to behave "like lists", and naturally wondered if I could write a Monad instance for them. But first, let's have a brief look at the definition of Source: data SourceResult a = Open a | Closed data PreparedSource m a = PreparedSource { sourcePull :: ResourceT m (SourceResult a) , sourceClose :: ResourceT m () } newtype Source m a = Source { prepareSource :: ResourceT m (PreparedSource m a) } ResourceT deals with resource acquisition and releasing (making sure that all resources are released), and provides a an abstraction over IORef/STRef. For our purposes here, ResourceT is probably close enough to IO. So now the question again is, can we write a Monad instance for this? I have been able to write join (concatenate) and return (a source with a single non-repeated) element. https://gist.github.com/1525471 I _think_ it behaves properly like a Monad, but I'm not quite sure, and neither was Michael. Greg Weber then suggested bringing the question to this forum. What made the question difficult for me is that this would be a stateful Monad transformer, so I'm not quite sure how to test the Monad laws properly. There's a second part to this question: If Source turns out not to be a Monad, is it possibly a ZipList-like Applicative? And either way, which is more useful: The list-like or the ziplist-like instances (of Applicative/Monad)? Thank you, Aristid

4 4

GSOC Proposal 2012 : HDBC
by Greg Weber 04 Apr '12

04 Apr '12

Hi Pranjal, We are glad you are interested in the GSoC. Please take a look at persistent: http://www.yesodweb.com/book/persistent It performs queries and serialization based on Haskell records. It also uses native drivers rather than HDBC. I created a proposal outline [1] and there is a student submission for it [2] [1] http://hackage.haskell.org/trac/summer-of-code/ticket/1605 [2] http://hackage.haskell.org/trac/summer-of-code/ticket/1605 Let me know if you are interested in that or need help coming up with a proposal Thanks, Greg Weber

1 0

mueval leaving behind tmp files
by Johannes Waldmann 04 Apr '12

04 Apr '12

The following program prints Right ("test","Bool","True") as it should, but it leaves behind in /tmp two files (name is a long string of digits) and an empty directory (name is ghcNNNNN_N). ... and it deletes the input file (/tmp/Main.hs). That's not nice. Ideally, I would want to read input from a String (instead of the file), and not write to disk at all. But cleaning up properly would be OK as a work-around. import Language.Haskell.Interpreter import Mueval.Interpreter import Mueval.ArgsParse main = do writeFile "/tmp/Main.hs" "test = True" result <- runInterpreter $ interpreter $ Options { timeLimit =1, modules =Just ["Prelude"], expression ="test" , loadFile ="/tmp/Main.hs", user="what", printType =True , extensions =False,namedExtensions = [] , noImports =False, rLimits =False, help=True } print result ghc --version The Glorious Glasgow Haskell Compilation System, version 7.4.1 ghc-pkg list| egrep 'mueval|hint' hint-0.3.3.4 mueval-0.8.1.1 uname -a Linux octopus 3.0.0-16-generic #29-Ubuntu SMP Tue Feb 14 12:48:51 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux

2 2

GSoC proposal: Units for GHC
by Nils Schweinsberg 04 Apr '12

04 Apr '12

Hi Haskell-Cafe & GHC-users! I'm looking to apply for the GSoC and since I've worked on GHC before I'd like to continue to do so. My proposal would be something that tempted me (as a physics student) for a while: Units for Haskell/GHC. This project has been suggested for a long time on the GHC wiki, and there is already a lot of work done for other languages like ML, F# etc[1]. I have tried to implement e.g. the unification algorithm from the "Types for Units-of-Measure in F#" talk[2] for an abstract syntax tree[3] and it was pretty much straight forward. As I see it, the project would consist of: 1.) Find appropriate rules/algorithms for unit analysis. Most (if not all?) of this should be covered in those papers/talks on [1]. 2.) Applying the rules to the Haskell syntax tree used in GHC. I have approximately 3 years of experience with Haskell, I worked for the database research group[4] at the University of Tübingen (Germany) on the Database Supported Haskell[5] library. I've done most of the coding for the monad comprehension[6] extension, which has been added to the latest GHC release version. I'm already quite familiar with the GHC internals of the compiler/typechecker, and even though I'd have to look up how exactly type interference etc. works in GHC (as I've only *used* it, but never tried to understand/modify it) I'm confident that the work on GHC itself should be doable in the given timeframe. So my questions would be: Do you think this is a appropriate GSoC project? What should I include in the application/project proposal? Anything else? Opinions, suggestions? I realize that I'm kind of late and probably should have written this email a long time ago. But there are still 2 days left for the student application and hopefully I'll get some good feedback by then. - Nils [1]: http://research.microsoft.com/en-us/um/people/akenn/units/index.html [2]: http://research.microsoft.com/en-us/um/people/akenn/units/MLWorkshop2008.pdf [3]: https://github.com/mcmaniac/units/blob/master/src/Unification.hs [4]: http://db.inf.uni-tuebingen.de/team [5]: http://hackage.haskell.org/package/DSH [6]: http://db.inf.uni-tuebingen.de/files/giorgidze/haskell2011.pdf

3 3