September 2019 - Haskell-Cafe

ANN brittany-0.12.0.0
by Evan Borden 28 Nov '19

28 Nov '19

Hello, I am happy to announce the release of brittany version 0.12.0.0. This version includes a number of fantastic improvements from many excellent contributors. Additionally brittany will soon be added back to stackage. In the meantime it can be built with the stack.yaml in its source or with cabal v2-build. https://hackage.haskell.org/package/brittany-0.12.0.0 Contributors ============ * Benjamin Kovach @5outh * Doug Beardsley @mightybyte * Evan Borden @eborden * Lennart Spitzner @lspitzner * Matt Noonan @moatt-noonan * Phil Hazelden @ChickenProp * Rupert Horlick @ruhatch * Sergey Vinokurov @sergv New Collaborators ================= You may be wondering why I am sending this message instead of Lennart. Taylor Fausak and I are taking on some of the maintenance for brittany. We will hopefully lift some of the burden from Lennart so he can remain the guiding light and driving force behind the project. Changes ========== This release includes many bug fixes, additional support for a number of syntactic constructs and a few layouting modifications. For full details check the change log on github: https://github.com/lspitzner/brittany/blob/master/ChangeLog.md Again thank you to brittany's fantastic contributors for helping making this release happen. -- Evan

2 1

[ANNOUNCE] GHC 8.8.1 is now available
by Ben Gamari 14 Nov '19

14 Nov '19

Hello everyone, The GHC team is pleased to announce the release candidate for GHC 8.8.1. The source distribution, binary distributions, and documentation are available at https://downloads.haskell.org/ghc/8.8.1 This release is the culmination of over 3000 commits by over one hundred contributors and has several new features and numerous bug fixes relative to GHC 8.6: * Visible kind applications are now supported (GHC Proposal #15) * Profiling now works correctly on 64-bit Windows (although still may be problematic on 32-bit Windows due to platform limitations; see #15934) * A new code layout algorithm for amd64's native code generator significantly improving the runtime performance of some kernels * The introduction of a late lambda-lifting pass which may reduce allocations significantly for some programs. * Further work on Trees That Grow, enabling improved code re-use of the Haskell AST in tooling * Users can write `forall` in more contexts (GHC Proposal #7) * The pattern-match checker is now more precise in the presence of strict fields with uninhabited types. * A comprehensive audit of GHC's memory ordering barriers has been performed, resulting in a number of fixes that should significantly improve the reliability of programs on architectures with weakly-ordered memory models (e.g. PowerPC, many ARM and AArch64 implementations). * A long-standing linker limitation rendering GHCi unusable with projects with cyclic symbol dependencies has been fixed (#13786) * Further work on the Hadrian build system * Countless miscellaneous bug-fixes Unfortunately, due to a build issue (#17108) found late in the release process i386 Windows builds are currently unavailable. These will be provided in the coming weeks. As always, if anything looks amiss do let us know. Happy compiling! Cheers, - Ben [1] https://downloads.haskell.org/ghc/8.8.1/docs/html/users_guide/8.8.1-notes.h…

8 14

Hedgehog: returning a list from `commandExecute` and getting to the items in an update function
by Magnus Therning 10 Oct '19

10 Oct '19

Hello, I'm trying to use Hedgehog to test a web app at work. Yesterday I ran into an issue with getting to the value returned from my `commandExecute` in an `Update` `Callback`. Basically my model looks like this ~~~ newtype State (v :: * -> *) = State (M.Map (Var UUID v) DataPerItem) deriving (Eq, Show) ~~~ and I have an action, `Command gen exec [Update update]` where ~~~ exec :: action -> m [UUID] ~~~ which results in ~~~ update :: State v -> action -> Var [UUID] v -> State v ~~~ AFAICS I need to, in order to actually update my model, turn that `Var [UUID] v` into `[Var UUID v]`. I've been staring at the functions in Hedgehog for a while now but nothing jumps out... or am I, once again, thinking about it all wrong? :) /M I also asked at stackoverflow: https://stackoverflow.com/questions/58157292/returning-a-list-and-getting-t… This is just to widen the net a bit... -- Magnus Therning OpenPGP: 0x927912051716CE39 email: magnus(a)therning.org twitter: magthe http://magnus.therning.org/ Ah, good taste! What a dreadful thing! Taste is the enemy of creativeness. — Pablo Picasso

1 2

hackage issues
by Richard Senington 30 Sep '19

30 Sep '19

Hi list, I have been trying to set up an account on Hackage to upload a project. I have created the account, but cannot get in contact with trustees to enable uploading. My mail servers (a university server) says that it cannot deliver the messages. Can anyone advise or assist? Richard

2 1

how to profile my code
by PICCA Frederic-Emmanuel 30 Sep '19

30 Sep '19

Hello, I would like to profile my code in order to find what is wrong with it. When I run it , I have a lot's of time took by the GC. 13,374,664,736 bytes allocated in the heap 16,149,779,248 bytes copied during GC 8,449,239,784 bytes maximum residency (617 sample(s)) 52,988,816 bytes maximum slop 15265 MB total memory in use (6808 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 7281 colls, 7281 par 80.304s 3.389s 0.0005s 0.0279s Gen 1 617 colls, 616 par 2508.056s 105.538s 0.1711s 0.6128s Parallel GC work balance: 32.20% (serial 0%, perfect 100%) TASKS: 51 (1 bound, 50 peak workers (50 total), using -N24) SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled) INIT time 0.013s ( 0.030s elapsed) MUT time 927.150s (101.039s elapsed) GC time 2349.743s ( 98.933s elapsed) RP time 0.000s ( 0.000s elapsed) PROF time 238.618s ( 9.993s elapsed) EXIT time 0.007s ( 0.001s elapsed) Total time 3515.531s (209.997s elapsed) Alloc rate 14,425,560 bytes per MUT second Productivity 26.4% of total user, 48.1% of total elapsed gc_alloc_block_sync: 524769 whitehole_spin: 2 gen[0].sync: 1375 gen[1].sync: 2139389 But If I use the Strict Extension in one of my file[1], this amount of time reduce drastically (the first run was done with a cold cache) This is why the MUT time is different. 13,364,299,032 bytes allocated in the heap 6,460,918,752 bytes copied during GC 8,423,062,112 bytes maximum residency (294 sample(s)) 55,571,872 bytes maximum slop 15265 MB total memory in use (6813 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 7455 colls, 7455 par 54.623s 2.330s 0.0003s 0.0279s Gen 1 294 colls, 293 par 782.773s 33.293s 0.1132s 0.5003s Parallel GC work balance: 61.24% (serial 0%, perfect 100%) TASKS: 51 (1 bound, 50 peak workers (50 total), using -N24) SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled) INIT time 0.013s ( 0.026s elapsed) MUT time 340.862s ( 64.620s elapsed) GC time 749.604s ( 31.920s elapsed) RP time 0.000s ( 0.000s elapsed) PROF time 87.791s ( 3.703s elapsed) EXIT time 0.011s ( 0.002s elapsed) Total time 1178.282s (100.271s elapsed) Alloc rate 39,207,331 bytes per MUT second Productivity 28.9% of total user, 64.4% of total elapsed gc_alloc_block_sync: 439663 whitehole_spin: 11 gen[0].sync: 922 gen[1].sync: 1129310 It is nice, but I would like to understand the real problem. I used hp2ps in order to monitor the memory usage, but my code is dominated by PINNED values (attached file) so I do not know where to start ? thanks for your advices. Frederic [1] https://repo.or.cz/hkl.git/blob/4cff5145d095683a40bc93cf8a0c0076f308244b:/c…

3 3

Munich Haskell Meeting, 2019-09-30 @ 19:30
by Leah Neukirchen 27 Sep '19

27 Sep '19

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Monday, September 30 at Augustiner-Gaststätte Rumpler at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-sep-2019/ Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

Stack overflow with ReadP
by Henry Laxen 25 Sep '19

25 Sep '19

Dear Haskell gurus, There has to be something very simple that I am misunderstanding here. I have tried sticking in trace statement, using the ghci debugger, but it just makes no sense to me. Please tell me what I am missing. Best wishes, Henry Laxen -------------------------------------------------------------------------------- module S where import Text.ParserCombinators.ReadP import Data.Char data Exp = Num Int | Add Exp Exp deriving (Eq, Show) expr :: ReadP Exp expr = do e <- (parseNumber +++ parseAdd) return e parseAdd :: ReadP Exp parseAdd = do e1 <- expr _ <- char '+' e2 <- expr return (Add e1 e2) parseNumber :: ReadP Exp parseNumber = do ds <- (munch1 isDigit) return . Num . read $ ds parse s = let parses = (readP_to_S expr) s in case parses of (p : _) -> fst (last parses) _ -> error "parse error" main = do print $ parse "1" λ> main *** Exception: stack overflow λ> parse "1+2" *** Exception: stack overflow -------------------------------------------------------------------------------- -- Nadine and Henry Laxen The rest is silence Villa Alta #6 Calle Gaviota #10 Never try to teach a pig to sing Chapala It wastes your time +52 (376) 765-3181 And it annoys the pig

5 4

Foldable, Traversable and choosing an order
by Juan Casanova 25 Sep '19

25 Sep '19

Hello again, haskell-cafe. I was trying to implement the Unifiable typeclass from Control.Unification on one of my types, and did so fine, but then realized I needed a Traversable instance. So I thought about it, and concluded: Yes, my type definitely is Traversable, and I implemented Traversable. But then I realized I needed a Foldable instance for that. And then I wasn't so sure anymore. I *can* implement a Foldable instance, but it requires a choice of the order in which my structure is traversed that I don't really want to make? A.k.a: I can think of at least two different ways of implementing Foldable that would give different results if the function passed to foldr was not associative. So I looked online a bit, and it seems this is a topic people have talked about, but maybe not precisely in the context of the order. What I have gathered is that: yes, if a functor is Traversable, then there is at least one way to implement a Foldable in it. And I understand this, but then, I don't really grasp how that works in my specific case. Because my Traversable instance does not make a choice of this order (at least I think so), and I do need to make that choice to implement Foldable (at least I think so), and I don't see how the "default" implementation of foldMap in terms of traverse makes that choice. But the choice must be made somewhere if it is made in the Foldable. So what is going on? Of course, here's the code. My types: data SOTermPF fn p f = ConstF fn | Proj Int | CompF p [f] deriving Eq newtype SOTermF fn f = SOF (SOTermPF fn f f) deriving Eq My Traversable instance (with comments on intermediate types because otherwise it can get pretty obscure): instance Traversable (SOTermF fn) where traverse f (SOF (ConstF c)) = pure (SOF (ConstF c)) traverse f (SOF (Proj idx)) = pure (SOF (Proj idx)) -- f g :: f b -- map f sargs = [f b] -- CompF :: a -> ([a] -> SOTermPF fn p a) -- (\h -> \ts -> SOF (CompF h ts)) :: ([a] -> SOTermF fn a) -- fmap (\h -> \ts -> SOF (CompF h ts)) (f g) :: f ([b] -> SOTermF fn b) -- traverse :: (aa -> ff bb) -> [aa] -> ff [bb] -- traverse :: (f b -> f b) -> [f b] -> f [b] -- ((fmap (\h -> \ts -> SOF (CompF h ts)) (f g)) <*>) :: f [b] -> f (SOTermF fn b) -- traverse id (map f sargs) :: f [b] -- (fmap (\h -> \ts -> SOF (CompF h ts)) (f g)) <*> (traverse id (map f sargs)) :: f (SOTermF fn b) traverse f (SOF (CompF g sargs)) = (fmap (\h -> \ts -> SOF (CompF h ts)) (f g)) <*> (traverse id (map f sargs)) But to implement Foldable I need to choose an order because in the case where I do have elements under the functor (CompF), I have them in two shapes: The "head" and the "arguments" (the p and the [f] in CompF p [f]). So, of course, the arguments are traversed in the order of the list, but the order that I need to choose is: Do I apply the head first and the arguments later or do I apply the arguments first and the head later? But my traverse seems so natural. Am I making that choice there? Maybe if I made the fmap over the arguments (while traversing the list) instead of over the head, and then did a flipped application of <*>? Does that mean my traverse instance has implicitly assumed that the head will be done first? All of this is really out of curiosity and making sure I know what I'm doing: I will not use foldr on my structure and I'm pretty sure that the traversal that Control.Unification needs is associative. But I don't like seeing arbitrary choices appear out of nowhere in my code, I want to make sure of why I made them. :P Thanks in advance, Juan. -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

6 9

JOB | Web Architect (London, UK)
by James Tobin 25 Sep '19

25 Sep '19

Hello, I'm working with an employer that is looking to hire a permanent front end architect to join their London office. You should have experience with Javascript and frameworks such as (but not only) React. Consequently, I had hoped that some members of this mailing list may like to discuss further off-list using "JamesBTobin (at) Gmail (dot) Com". Kind regards, James

2 1

ANN: network 3.1.1.0
by Evan Borden 23 Sep '19

23 Sep '19

I'm happy to announce the release of network 3.1.1.0. http://hackage.haskell.org/package/network-3.1.1.0 Changes: - A new API: gracefulClose. #417 <https://github.com/haskell/network/pull/417> Also see Kazu's blog post on the design choices in this function https://kazu-yamamoto.hatenablog.jp/entry/2019/09/20/165939 - touchSocket, unsafeFdSocket: Allow direct access to a socket's file descriptor while providing tools to prevent it from being garbage collected. This also deprecated fdSocket in favor of unsafeFdSocket and withFdSocket. #423 <https://github.com/haskell/network/pull/423> - socketToFd: Duplicates a socket as a file descriptor and closes the source socket. #424 <https://github.com/haskell/network/pull/424> As always thank you to network's contributors.

1 0