- Haskell-Cafe - Haskell.org

ANN: stack-2.1 second release candidate
by Emanuel Borsboom 03 Jun '19

03 Jun '19

Announcing the second release candidate for Stack 2.1! This is the version that will be released one week from now if there aren't any major issues discovered, so please give it a try. You can download bindists for Linux, macOS, and Windows from https://github.com/commercialhaskell/stack/releases/tag/v2.1.0.3 **Changes since v2.1.0.1** Other enhancements: * Add `--docker-mount-mode` option to set the Docker volume mount mode for performance tuning on macOS. Bug fixes: * Fix regression where `stack --docker` would quit after 20 seconds on macOS.

1 0

"-with-rtsopts=-T" solved the memory leak
by Vlatko Basic 29 May '19

29 May '19

Hello, I accidentally solved a memory leak just by enabling "with-rtsopts=-T". I knew where the issues was, in one servant client web call. It was showing even when the call result (a Bool) wasn't used. While the leak was "active", I had: ghc-options: -threaded -rtsopts -with-rtsopts=-N And now that it doesn't show anymore, I have: ghc-options: -threaded -rtsopts -with-rtsopts=-N -with-rtsopts=-T I can reproduce the leak just by commenting out "-with-rtsopts=-T" and force rebuilding. Can anyone explain what is happening? Best regards, vlatkoB

1 0

Fwd: Two weeks left for Haskell Exchange talk proposals
by Spiwack, Arnaud 29 May '19

29 May '19

Dear all, Only two weeks remain before the end of the Haskell eXchange call-for-paper (11th of june). Send your proposals! This year's keynote speaker will be Elise Huard, Gabriele Keller, Simon Peyton Jones, and Philip Wadler. Find the full CFP and submit your proposal here: https://docs.google.com/forms/d/e/1FAIpQLSeJgeTqAdYLBlRcO9PDzI3yrR22CqzhInH…

1 0

A "less" complex median
by Michel Haber 29 May '19

29 May '19

Hello Cafe, I wanted to try and write a median filter with good complexity and performance. This is just an exercise, so there is no use looking for better performance algorithms (median of medians). Below is the code I came up with: import Control.Monad.State import System.Random type MyState s = State (Int, Int, [(Int, s)]) -- Inserts a value in its sorted place, -- Removes all expired values encountered, -- Returns the median value of the list. insertSorted :: (Ord a) => a -> MyState a a insertSorted v = do (size, index, list) <- get let flt = valid size index -- Filter: If too old remove value cmp (_,x) = v < x -- Compare: If v spot reached, add v ret = min index size `div` 2 -- The return value's index let (newList, med) = goThrough flt cmp ret (index, v) list put (size, index + 1, newList) return . snd $ med -- Internal implementation goThrough :: (a -> Bool) -> (a -> Bool) -> Int -> a -> [a] -> ([a], a) goThrough _ _ _ v [] = ([v], v) goThrough flt cmp idx v ls@(x:xs) | flt x && cmp x = if idx == 0 then (v:ls, v) else (v:ls, getTo idx (v:ls)) | flt x = let (ys, y) = goThrough flt cmp (max 0 (idx-1)) v xs in if idx == 0 then (x:ys, x) else (x:ys, y) | otherwise = goThrough flt cmp idx v xs -- Continues going through the list until we get to the element we want, or we -- run out of elements, in which case we take the last one getTo :: Int -> [a] -> a getTo _ [] = error "No value to return!" getTo _ [x] = x getTo 0 (x:_) = x getTo i (_:xs) = getTo (i-1) xs -- A value is valid if it still has a place in the list (hasn't expired) valid :: Int -> Int -> (Int, a) -> Bool valid size index (i,_) = index - i < size -- Clean up all the old values in the list. This is costly, and should be -- performed sparingly clean :: MyState Double () clean = do (size, index, list) <- get put (size, index, filter (valid size index) list) -- Insert n values with insertSorted insertList :: [Double] -> MyState Double [Double] insertList ls = sequence $ insertSorted <$> ls -- Example main :: IO () main = do values <- sequence $ replicate 10000 $ randomRIO (1,100::Double) print $ runState (insertList values <* clean) (10, 0, []) return () The code works, at least in the simple cases I've tried. It seems, however, way too complex and not very composable. So I was wondering if anyone could tell me where I went wrong, and how I can make the code simpler and smaller. Of course, it is completely possible to divide my insertion function, but the goal is to do all of the steps in one iteration over the list. This allows me to later compare what I have with divided functions to discover if the compiler would optimize them into one traversal. But even with its current logic, I believe the code can be better written. I just don't know how :p So I really appreciate any advice on how to make it better (or fix a bug I missed, or maybe even the logic of the whole algorithm). Cheers, Michel :)

2 2

ANN: Elminator (Haskell to Elm code generator for Elm 0.19/0.18)
by sras 28 May '19

28 May '19

Happy to announce 'Elminator', a package for generating Elm source for type definitions and Json encoders/decoders from Haskell data type definitions. https://hackage.haskell.org/package/elminator, This package tries to address some issues with popular/existing packages in the same space. Some distinguishing features are.. 1. Supports generation of polymorphic types (as well as concrete ones) in Elm from possibly polymorphic Haskell types, including types with phantom type variables. 2. Supports generation of code for recursive types (direct/indirect) as long as the type is not polymorphic. 3. Generates code that does not depend on external Elm libraries. 4. Does not have limits on the number of fields that the constructors of your types can have. 5. Supports JSON encoding options exported by the Aeson library comprehensively. 6. Supports generation of code that depend on user defined types and encoders/decoders in Elm. Right now this package is tested by using a Haskell/Elm test app that round trips a bunch of data structures between an Elm front end and a Haskell back end, so as of now, there there aren't any automated tests included with this repo. Any feedback is welcome! Thanks.

1 0

Emacs org-mode code block problems
by Lawrence Bottorff 28 May '19

28 May '19

I've got this in an Emacs org-mode code block: #+begin_src haskell :results output doubleSmallNumber4 x = if x > 0 then x else x * 2 #+end_src but when I try to run it (with C-c C-c) I get ... Prelude> doubleSmallNumber4 x = if x > 0 then x else x * 2 "org-babel-haskell-eoe" <interactive>:19:23: error: parse error (possibly incorrect indentation or mismatched brackets) Prelude> <interactive>:20:11: error: parse error (possibly incorrect indentation or mismatched brackets) Prelude> <interactive>:21:5-8: error: parse error on input ‘then’ Prelude> <interactive>:22:5-8: error: parse error on input ‘else’ Prelude> "org-babel-haskell-eoe" ... I can run #+begin_src haskell tripleMe x = x + x + x #+end_src just fine though -- which means I've done something right with my Emacs init. The REPL started is 8.6.3 stack-ghci. I've formatted with the org-mode C-c '

1 0

How to make boolean logic with IO Monad more expressive?
by Magicloud Magiclouds 28 May '19

28 May '19

Hi, I think `a || b && c` is more clear than ``` if a then True else if b then if c then True else False else False ``` And some languages, `pureComputing || (ioOperation && pure2)` involves IO only when pureComputing is False. So in Haskell, is it possible to get both benefits? ``` status <- ioOperation -- IO-ed anyway return $ pureComputing || (status && pure2) ``` ``` if pureComputing then return True else do status <- ioOperation if status then return pure2 else return False -- Looks ugly ```

4 9

Call for papers for IFL 2019 (Implementation and Application of Functional Languages)
by Jurriaan Hage 27 May '19

27 May '19

Hello, Please, find below the call for papers for IFL 2019. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- ================================================================================ IFL 2019 31st Symposium on Implementation and Application of Functional Languages National University of Singapore September 25th-27th, 2019 http://2019.iflconference.org ================================================================================ ### Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2019 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications ### Keynote Speaker * Olivier Danvy, Yale-NUS College ### Submissions and peer-review Differently from previous editions of IFL, IFL 2019 solicits two kinds of submissions: * Regular papers (12 pages including references) * Draft papers for presentations ('weak' limit between 8 and 15 pages) Regular papers will undergo a rigorous review by the program committee, and will be evaluated according to their correctness, novelty, originality, relevance, significance, and clarity. A set of regular papers will be conditionally accepted for publication. Authors of conditionally accepted papers will be provided with committee reviews along with a set of mandatory revisions. Regular papers not accepted for publication will be considered as draft papers, at the request of the author. Draft papers will be screened to make sure that they are within the scope of IFL, and will be accepted for presentation or rejected accordingly. Prior to the symposium: Authors of conditionally accepted papers and accepted presentations will submit a pre-proceedings version of their work that will appear in the draft proceedings distributed at the symposium. The draft proceedings does not constitute a formal publication. We require that at least one of the authors present the work at IFL 2019. After the symposium: Authors of conditionally accepted papers will submit a revised versions of their paper for the formal post-proceedings. The program committee will assess whether the mandatory revisions have been adequately addressed by the authors and thereby determines the final accept/reject status of the paper. Our interest is to ultimately accept all conditionally accepted papers. If you are an author of a conditionally accepted paper, please make sure that you address all the concerns of the reviewers. Authors of accepted presentations will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal post-proceedings. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected. ### Publication The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication ### Important dates Submission of regular papers: May 31, 2019 Submission of draft papers: July 15, 2019 Regular and draft papers notification: August 1, 2019 Deadline for early registration: August 15, 2019 Submission of pre-proceedings version: September 15, 2019 IFL Symposium: September 25-27, 2019 Submission of papers for post-proceedings: November 30, 2019 Notification of acceptance: January 31, 2020 Camera-ready version: February 29, 2020 ### Submission details All contributions must be written in English. Papers must use the ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2019 ### Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. ### Organization and Program committee Chairs: Jurrien Stutterheim (Standard Chartered Bank Singapore), Wei Ngan Chin (National University of Singapore) Program Committee: - Olaf Chitil, University of Kent - Clemens Grelck, University of Amsterdam - Daisuke Kimura, Toho University - Pieter Koopman, Radboud University - Tamas Kozsik, Eotvos Lorand University - Roman Leschinskiy, Facebook - Ben Lippmeier, The University of New South Wales - Marco T. Morazan, Seton Hall University - Sven-Bodo Scholz, Heriot-Watt University - Tom Schrijvers, Katholieke Universiteit Leuven - Alejandro Serrano, Utrecht University - Tony Sloane, Macquarie University - Simon Thompson, University of Kent - Marcos Viera, Universidad de la Republica - Wei Ngan Chin, NUS - Jurrien Stutterheim, Standard Chartered Bank ### Venue The 31st IFL is organized by the National University of Singapore. Singapore is located in the heart of South-East Asia, and the city itself is extremely well connected by trains and taxis. See the website for more information on the venue. ### Acknowledgments This call-for-papers is an adaptation and evolution of content from previous instances of IFL. We are grateful to prior organizers for their work, which is reused here. A part of IFL 2019 format and CFP language that describes conditionally accepted papers has been adapted from call-for-papers of OOPSLA conferences.

1 0

Is there already a lib to work with filepath glob?
by Magicloud Magiclouds 26 May '19

26 May '19

Hi, Say for logic of Bash code `for f in /somePath/*/*; do ... done`, with filepath, directory packages, I have to do something like `listDirectoryContent "somePath" >>= mapM_ (\fp -> listDirectoryContent fp >>= action)`. It is not as expressive as the script. Especially when I'd like to use conduit to stream the folder. So is there already something I can use to make the logic expressive? PS: I know there are some libs to match a filepath against a glob string. But that is not what I want.

1 1

haskell-src-exts - no more releases
by Matthew Pickering 26 May '19

26 May '19

Hi all, I have decided that I am not going to do any more releases of `haskell-src-exts`. (https://github.com/haskell-suite/haskell-src-exts) If anyone wants to become the maintainer then I will gladly transfer rights to the repo. I advise anyone who wants to parse Haskell programs to use the GHC API, specifically you can use `ghc-lib-parser`. https://hackage.haskell.org/package/ghc-lib-parser Cheers, Matt

2 1