October 2014 - Haskell-Cafe

Re: [Haskell-cafe] Increasing Haskell modularity
by oleg＠okmij.org 27 Nov '14

27 Nov '14

The issue with local instances is very complicated one. First, they are sorely missed. However, they present quite a problem. Let us assume they are implemented and consider the following function f1 :: Int -> String f1 x = let instance Show Int where show _ = "one" in show x I think we all agree (f1 1) should evaluate to "one". However, given f2 :: Show a => a -> String f2 x = let instance Show Int where show _ = "one" in show x what should (f2 (1::Int)) return? One answer is that it should still return "one" -- that is, local instances should sort of form a closure (like local variables in the real closure). That is a good answer, but may lead to unpleasant surprises because the fact of the closure is not at all reflected in the type of the function. Consider data T = T f3 :: Show a => a -> String f3 x = let instance Show T where show _ = "T" in show x and take the closure semantics. The type says that to make (f3 T) well-typed, there has to be an instance Show T in scope. The user of f3 has no way to know of the private local instance that is closed over (short of examining the source code). Since the user knows there is no global instance T, the user attempts to define in. The user will be quite surprised to discover that (f3 T) is well-typed but their global instance Show T has no effect. Let us assume the opposite of the closure semantics -- local instances are not closed. So, local instances should behave sort of dynamically scoped variables (which are not captured in closures). Therefore, (f2 (1::Int)) should return "1". Such a choice is also problematic. Suppose GHC, seeing our call to f2, notices that the polymorphic f2 is called at type Int and decides, to save time on indirect dictionary calls, to specialize f2 to the type Int. So, GHC will generate a specialized instance of f2: f2_Int :: Int -> String f2_Int x = let instance Show Int where show _ = "one" in show x and we have already decided that (f2_Int 1), should return "one" rather than "1" (since f2_Int looks just like f1). Previously, specialization of a function was easy to understand: GHC may, at will, create a copy of a polymorphic function and instantiate it at a specific type. Then all calls to the polymorphic function at that specific type are replaced with the calls to the specialized function. The user can even do such a specialization themselves. With unclosed local instances, such a specialization changes the program behavior. We have to complicate the matters. Further, what should (f4 (1::Int)) return? f4 :: Show a => a -> String f4 x = let instance Show Int where show _ = "two" in f2 x Stefan Kaes, the person who introduced ``parametric overloading'' (type classes, in modern term) chose the ``closure semantics''. His system and prototype implementation had only local instances (and even local type classes). http://okmij.org/ftp/Computation/typeclass.html#Kaes Perhaps the most comprehensive treatment of local instances is the old paper D. Duggan and J. Ophel. Open and closed scopes for constrained genericity (PDF). Theoretical Computer Science, 275, 215-258, 2002. http://dl.acm.org/citation.cfm?id=570578 They propose a method to have both closure and non-closure semantics, differentiating based on so-called open and closed types. Our HW 2004 paper with Chung-chieh Shan proposed a way to elide the problem by restricting the local instances in such a way that the problem never arises. The `reflection' facility was used to implement such local instances. The idea was that local instances can be thought of as ordinary global instances; however, the scope of the type in their head is restricted. That is, rather than make the instances local we make local the type for which they are defined (or one of the types, for multi-parameter type classes). Local types can be emulated via first-class polymorphism. (BTW, if one can leave with unsafeCoerce, local instances can be much more efficiently implemented.) Gesh wrote: > * Give up on non-associated open type families. This I have > researched less well, but it seems to me that these have no use > case. Since one can make whatever instances one wishes for these type > families, one can't do anything useful with values of their instances. On the contrary, we found them very useful in defining interpreters that provide their own interpretation of not only primitives but also of types. http://okmij.org/ftp/gengo/NASSLLI10/index.html See, for example, http://okmij.org/ftp/gengo/NASSLLI10/Lambda.hs for partial evaluation and http://okmij.org/ftp/gengo/NASSLLI10/CFG.hs In the latter case, extensibility is particularly important as we do want to add further syntactic categories and their semantic interpretations.

6 5

Monads: external questions
by Jeffrey Brown 22 Nov '14

22 Nov '14

As opposed to the internal logic of monads, how they work, I hope to start a discussion about their external logic: how and why to use monads. design ------ How do monads change the way one * thinks about a problem? * structures data? * refactors? * tests? Should I always be giving the monads a lot of cognitive bandwidth, because they reorder the way everything should be, or is it an investment with a high initial cognitive cost but requiring little maintenance thereafter? what is their common framework? ------------------------------- Monads let data reach farther than it otherwise would. Subjectively, they feel like a controlled way of violating encapsulation. Are there other, deeper or more specific, commonalities that explain why monads are a good way to implement exceptions, output, state, and perhaps other services? varieties --------- In practice, are all monads either for exceptions, state or output? If not, what other goals are monads well suited to? How should multiple contexts coexist? What's a simple Haskell program that uses more than one kind of monad in the same scope? Should, say, output and state be nestled in parallel into a three-attribute monad (the third variable being the type variable), or would it instead be better to create separate output and state monads? If each context should have a separate monad, is it a good idea to nest them, or somehow otherwise let them overlap, within a particular function or scope? temptations to err ------------------ I have a vague sense that a common pitfall is to use monads to do things in a procedural way that eliminates the benefits of a functional language, but I'm not sure I would recognize it if I were making that error. I feel like I could learn from a comparison of code that works and uses monads badly to code that does better.

5 6

Test Framework, HUnit
by spopejoy 09 Nov '14

09 Nov '14

Hi, I started using Test Framework following the example of the lens library, specifically using Test.Framework.TH. It looks really nice, however I noticed that the TH project hasn't had any activity in 2 years ... plus the whole test framework project is very light on docs. I've been happy with straight HUnit, but I'm wanting something more structured to bring others into the project I'm working on. 1) Are there more resources on TF? 2) Is TF-TH actively maintained? Cheers, Stuart

5 5

Fwd: Increasing Haskell modularity
by Gesh hseG 07 Nov '14

07 Nov '14

Sorry, should have used reply-list. To clarify, under the proposal, the associated family instances would also be locally unique, with local instances overriding global instances. Gesh ---------- Forwarded message ---------- From: Gesh <gesh(a)gesh.uni.cx> Date: Wed, Oct 1, 2014 at 5:30 PM Subject: Re: [Haskell-cafe] Increasing Haskell modularity To: Richard Eisenberg <eir(a)cis.upenn.edu> On 10/1/2014 5:01 PM, Richard Eisenberg wrote: > > * I'm not sure exactly what you mean by "adopt [Oleg's] proposal". In Section 6.1, Oleg discusses how to keep principal typing while allowing local instances. He then suggests making this part of the semantics of local instances. > It seems the first part of your proposal just says > "Haskellers can no longer expect class instance coherence." > As such, this is a drastic change that would require all Haskell > programs to be inspected to see if they crucially rely on coherence No. Coherence is preserved, since you always use the unique in-scope dictionary. What *is* lost, however, is global uniqueness, which means that code that assumes that the same dictionary is used for the same type across calls to functions must be modified. Arguably, that code is semantically incorrect to begin with, but that's neither here nor there. > * As for associated vs. non-associated type families: > There is essentially no difference between associated > and non-associated type families, save concrete syntax. > If the Haskell house were on fire and we needed to eliminate > one of these forms, I would agree to it without much trouble, > because the two forms are equally expressive. > > > But, eliminating non-associated type families wouldn't solve > your problem at all: while class instance incoherence causes > wonky runtime behavior, associated type instance incoherence > breaks the type system. If I understand your proposal correctly, > users could implement unsafeCoerce through clever hackery around > associated type instance incoherence. This seems to be against > the Haskell tradition of strong typing. To clarify my proposal: Associated type families have the added guarantee over non-associated families that functions will be defined that allow one to work with them. As mentioned above, typeclass coherence is preserved under the proposal, so I see no danger of family incoherence. However, I'm inexperienced with these kinds of proposals, and the concern that unsafeCoerce will be possible with this proposal is worrying. Could you please construct a case implementing unsafeCoerce? Thanks, Gesh

15 26

Debugging Wreq/http-client https requests
by Cody Goodman 05 Nov '14

05 Nov '14

I have a program that is POST'ing some data to a remote server. However, some part of the data I'm sending is wrong I believe. If this were plain http without encryption, wireshark would allow me to see the exact data being sent over the wire. However, with https it is encrypted. Is there an inbuilt way to debug requests sent by wreq or more likely, a way to output debug info for http-client? Alternatively, is there a way to use NSS support with either of these libraries: http://security.stackexchange.com/questions/35639/decrypting-tls-in-wiresha… Thanks in advance to all for your time.

4 5

<|> that short-circuits in IO ?
by Semen Trygubenko / Семен Тригубен ко 02 Nov '14

02 Nov '14

Dear Haskell-Cafe, Is there a way to get Control.Applicative.<|> to short-circuit when combining two IO actions? E.g. > let a = putStrLn "A" >> return (Left "hehe") > let b = putStrLn "B" >> return (Right 42) > Prelude> liftA2 (<|>) a b A B Right 42 > liftA2 (<|>) b a B A Right 42 (In the latter case I don't want A in the output…) Many thanks for your help, Semen -- Семен Тригубенко http://trygub.com

4 6

Hackage inconsistent? (pandoc.cabal in 1.13.1)
by Magnus Therning 31 Oct '14

31 Oct '14

It seems pandoc 1.13.1 package on hackage has gotten into an insonsistent state. I just noticed this strange situation with the dependency on http-client: pandoc.cabal at [1] has if flag(https) Build-Depends: http-client >= 0.3.2 && < 0.5, http-client-tls >= 0.2 && < 0.3, http-types >= 0.8 && < 0.9 cpp-options: -DHTTP_CLIENT pandoc.cabal found in [2] has if flag(https) Build-Depends: http-client >= 0.3.2 && < 0.4, http-client-tls >= 0.2 && < 0.3, http-types >= 0.8 && < 0.9 cpp-options: -DHTTP_CLIENT How can something like this even happen? /M [1]: http://hackage.haskell.org/package/pandoc-1.13.1/pandoc.cabal [2]: http://hackage.haskell.org/package/pandoc-1.13.1/src/pandoc.cabal -- Magnus Therning OpenPGP: 0xAB4DFBA4 email: magnus(a)therning.org jabber: magnus(a)therning.org twitter: magthe http://therning.org/magnus Any fool can write code that a computer can understand. Good programmers write code that humans can understand. -- Martin Fowler

14 28

Getting the haddocks back (was: documentation build failing in hackage?)
by Rogan Creswick 30 Oct '14

30 Oct '14

On Sun, Oct 12, 2014 at 4:50 AM, Mateusz Kowalczyk <fuuzetsu(a)fuuzetsu.co.uk> wrote: > > The biggest problem is that there is no official statement as to why the > builds stopped and an estimate of when they are coming back. > I agree! My understanding (which is at /least/ 2nd or 3rd hand) is that the doc builds were turned off intentionally because it was a security issue, and that they are unlikely to come back. Now, assuming that is the case, how can we solve the "there is no documentation" issue? Some ideas to kick-start discussion: - Provide an option to include haddocks in the sdist bundle, and extract them on Hackage for display. - Add a 'cabal uploadHaddock' - Run all haddock builds in a VM/docker container / etc.. that mitigates the security concerns. - ??? --Rogan

10 18

Haskell Weekly News: Issue 311
by Daniel Santa Cruz 29 Oct '14

29 Oct '14

Welcome to issue 311 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers from October 19 to 25, 2014 Quotes of the Week * trap_exit: isn't darcs this haskell powered quantum physics simulator that happens to also keep revisions of files? Top Reddit Stories * "GHC uses GMP, and its performance is nothing short of extraordinary. GHC is clearly tuned to call into GMP with extremely low overheads." Domain: wilfred.me.uk, Score: 79, Comments: 26 Original: [1] http://goo.gl/n6tXA3 On Reddit: [2] http://goo.gl/zTH1v5 * Video games in Haskell: Chips Challenge demo Domain: vimeo.com, Score: 73, Comments: 22 Original: [3] http://goo.gl/EyUQ6t On Reddit: [4] http://goo.gl/8Lrj3I * HLint now spots bad unsafePerformIO Domain: neilmitchell.blogspot.it, Score: 56, Comments: 29 Original: [5] http://goo.gl/sxFywP On Reddit: [6] http://goo.gl/nA0rvs * Seemingly impossible functional programs Domain: math.andrej.com, Score: 56, Comments: 15 Original: [7] http://goo.gl/gtXO9 On Reddit: [8] http://goo.gl/XdTGd7 * New blog post: "Quasi-quoting DSLs for free" Domain: well-typed.com, Score: 55, Comments: 2 Original: [9] http://goo.gl/QbblTr On Reddit: [10] http://goo.gl/hv43hU * Flocking behaviour simulation written using helm. Source in comments. Domain: gfycat.com, Score: 46, Comments: 9 Original: [11] http://goo.gl/MegczW On Reddit: [12] http://goo.gl/aKma9A * Finished reading Learn You a Haskell, please recommend me book number 2: Domain: self.haskell, Score: 41, Comments: 24 Original: [13] http://goo.gl/uQiplX On Reddit: [14] http://goo.gl/uQiplX * Simple Haskell IRC client in "two lines of code" Domain: self.haskell, Score: 40, Comments: 62 Original: [15] http://goo.gl/7SQpZL On Reddit: [16] http://goo.gl/7SQpZL * GPU Programming in Haskell (video) Domain: looprecur.com, Score: 36, Comments: 0 Original: [17] http://goo.gl/7N0rgb On Reddit: [18] http://goo.gl/kjuFle * Are there ANY good game engines for haskell? Domain: self.haskell, Score: 33, Comments: 38 Original: [19] http://goo.gl/6ugfSM On Reddit: [20] http://goo.gl/6ugfSM * Darcs turns 12 Domain: hub.darcs.net, Score: 30, Comments: 8 Original: [21] http://goo.gl/tnNsyR On Reddit: [22] http://goo.gl/DXIYyW Top StackOverflow Questions * Dependent Types: How is the dependent pair type analogous to a disjoint union? votes: 20, answers: 6 Read on SO: [23] http://goo.gl/HOSXJO * How should I read this GHC Core “proof”? votes: 11, answers: 0 Read on SO: [24] http://goo.gl/3btTZT * more efficient type-level computations using type families? votes: 11, answers: 0 Read on SO: [25] http://goo.gl/LHYecG * How to make fmap rewrite rules fire? votes: 10, answers: 1 Read on SO: [26] http://goo.gl/JrjnJH * A workaround for the “Template Haskell + C” bug? votes: 8, answers: 1 Read on SO: [27] http://goo.gl/q9sIHZ * Transform a -> a -> Maybe a to take any combination of a's and Maybe a's votes: 8, answers: 2 Read on SO: [28] http://goo.gl/AS4kC0 * Making numeric functions an instance of Num? votes: 7, answers: 2 Read on SO: [29] http://goo.gl/6uNuWB * Inverting a Type Family votes: 7, answers: 2 Read on SO: [30] http://goo.gl/18XHro * FRP frameworks and IO votes: 7, answers: 1 Read on SO: [31] http://goo.gl/BbEWOM Until next time, [32]+Daniel Santa Cruz References 1. http://www.wilfred.me.uk/blog/2014/10/20/the-fastest-bigint-in-the-west/ 2. http://www.reddit.com/r/haskell/comments/2jt37u/ghc_uses_gmp_and_its_perfor… 3. https://vimeo.com/109613639 4. http://www.reddit.com/r/haskell/comments/2jwwlj/video_games_in_haskell_chip… 5. http://neilmitchell.blogspot.it/2014/10/hlint-now-spots-bad-unsafeperformio… 6. http://www.reddit.com/r/haskell/comments/2jsa4c/hlint_now_spots_bad_unsafep… 7. http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/ 8. http://www.reddit.com/r/haskell/comments/2k0xg2/seemingly_impossible_functi… 9. http://www.well-typed.com/blog/2014/10/quasi-quoting-dsls/ 10. http://www.reddit.com/r/haskell/comments/2jowjc/new_blog_post_quasiquoting_… 11. http://gfycat.com/WearyAnguishedIggypops 12. http://www.reddit.com/r/haskell/comments/2k51kk/flocking_behaviour_simulati… 13. http://www.reddit.com/r/haskell/comments/2kbnzw/finished_reading_learn_you_… 14. http://www.reddit.com/r/haskell/comments/2kbnzw/finished_reading_learn_you_… 15. http://www.reddit.com/r/haskell/comments/2jvc78/simple_haskell_irc_client_i… 16. http://www.reddit.com/r/haskell/comments/2jvc78/simple_haskell_irc_client_i… 17. http://looprecur.com/blog/gpu-programming-in-haskell/ 18. http://www.reddit.com/r/haskell/comments/2jp9y9/gpu_programming_in_haskell_… 19. http://www.reddit.com/r/haskell/comments/2k93sm/are_there_any_good_game_eng… 20. http://www.reddit.com/r/haskell/comments/2k93sm/are_there_any_good_game_eng… 21. http://hub.darcs.net/darcs/darcs-screened/patch/20021020200105-e9342 22. http://www.reddit.com/r/haskell/comments/2jsvnd/darcs_turns_12/ 23. http://stackoverflow.com/questions/26542350/dependent-types-how-is-the-depe… 24. http://stackoverflow.com/questions/26524223/how-should-i-read-this-ghc-core… 25. http://stackoverflow.com/questions/26538595/more-efficient-type-level-compu… 26. http://stackoverflow.com/questions/26568262/how-to-make-fmap-rewrite-rules-… 27. http://stackoverflow.com/questions/26449154/a-workaround-for-the-template-h… 28. http://stackoverflow.com/questions/26520261/transform-a-a-maybe-a-to-take-a… 29. http://stackoverflow.com/questions/26515102/making-numeric-functions-an-ins… 30. http://stackoverflow.com/questions/26541893/inverting-a-type-family 31. http://stackoverflow.com/questions/26560100/frp-frameworks-and-io 32. https://plus.google.com/105107667630152149014/about

1 0

Polymorphic functions over string libraries
by gonzaw 29 Oct '14

29 Oct '14

Hi. I was wondering what would be the best way to create a polymorphic function over any possible string library (Text, String, Bytestring, etc). For instance, imagine I have to read a file with text, transform this text in some way and output it to another file, or to the console. If I wanted to use String, I'd just do this: / transform :: String -> String main = readFile "input.txt" >>= writeFile "output.txt" . transform / But if I wanted to use Text instead, I'd have to use this: / import qualified Data.Text.IO as T transform :: Text -> Text main = T.readFile "input.txt" >>= T.writeFile "output.txt" . transform / Idem for ByteString. I was wondering if there was a way to create these computations in a generic way, for any kind of string library, something like this: / class StringLibrary s where: sReadFile :: FilePath -> IO s sWriteFile :: FilePath -> s -> IO () ... / So then I'd just have this: / transform :: StringLibrary s => s -> s main = sReadFile "input.txt" >>= sWriteFile "output.txt" . transform / Now I can perform the computation I want without being tied down to a specific library. At times when I create some quick scripts, I find myself using one library (for example using String to get it finished more quickly, since I have less experience with the other ones), but find that it's too slow or has some problem that is solved by using one of the other libraries. Yet swapping from one to the other is more cumbersome than expected at times. In the example above, I could easily swap between them, just by forcing the compiler to typecheck to a specific one (for instance by changing the type of "transform"). Or if I wanted to, I could leave it as it is and export it as a library of my own. Is there a way to do something like this in Haskell, with existing libraries? In terms of using the string datatype as some sort of container of characters, I think there are libraries like Lens and mono-traversable that allow you to do stuff like this. But I'm not too familiar with them (at least using them in this way). -- View this message in context: http://haskell.1045720.n5.nabble.com/Polymorphic-functions-over-string-libr… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

9 10