- Haskell-Cafe - Haskell.org

Planet Haskell
by Joachim Breitner 22 Nov '19

22 Nov '19

Hi, I am reading planet haskell through a feed reader that pulls https://planet.haskell.org/atom.xml and I get new posts. But it seems that that https://planet.haskell.org/ is stuck in January 2019. Or, upon closer inspection, new posts _are_ on planet.haskell.org, but they are not on top. I guess in the times of reddit and slack, few people are following the planet, but maybe still some people do? Cheers, Joachim -- Joachim Breitner mail(a)joachim-breitner.de http://www.joachim-breitner.de/

3 2

Re: [Haskell-cafe] Transforming from on State-transformer to another
by Olaf Klinke 22 Nov '19

22 Nov '19

> Am 21.11.2019 um 22:56 schrieb Jacques Carette <carette(a)mcmaster.ca>: > > On 2019-Nov.-21 15:57 , Olaf Klinke wrote: >>> Is there a way to have a function of type (a -> b) -> State a c -> State >>> b c ? >> djinn says no. The reason ist that the a occurs both positively and negatively in State a c, that is, on the left and the right hand side of the -> in State. >> >>> In the particular case of interest, I am interested in is actually b -> >>> State a c -> (State (a,b) c), which is of course a special case of the >>> above. >> djinn says yes. The suggested term is >> >> \f -> \(a,b) -> let (a,c) = f a in ((a,b),c) > > > Thanks. I tried to play with the online djinn to ask about exactly this - and failed! How should I be asking? I downloaded the djinn package and built it with cabal. > > Also, something is weird about that term, since it doesn't match "b -> State a c -> (State (a,b) c)" at all. It does match "(b -> State a c) -> (State (a,b) c)" which is a completely different type (and not interesting...) Sorry, I tried to simplify djinn's output and failed. The term should be \f -> \(a,b) -> let (c,a') = f a in (c,(a',b)) :: (a -> (c, a3)) -> (a, b) -> (c, (a3, b)) where you can let a3 = a to get State a c -> State (a,b) c That is, it maps a transformer of state a into a transformer of state (a,b) that leaves the b component unchanged. Olaf

1 0

Re: [Haskell-cafe] filepath
by Johannes Waldmann 21 Nov '19

21 Nov '19

Dear Cafe, is there a library that provides an "abstract representation of file and directory pathnames"? This had been discussed before - e.g., https://mail.haskell.org/pipermail/libraries/2007-December/008769.html (it's one message of a longer thread) That message references an obsolete (?) Java library, they now have https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/nio/file/… It seems that https://hackage.haskell.org/package/filepattern-0.1.1/docs/System-FilePatte… does cover typical usage. It is based on FilePath = String, and its implementation has some "++"-ing. That indicates that an abstraction layer is missing - or, that such a layer is indeed not required? - J.W.

2 1

Transforming from on State-transformer to another
by Jacques Carette 20 Nov '19

20 Nov '19

Is there a way to have a function of type (a -> b) -> State a c -> State b c ? In the particular case of interest, I am interested in is actually b -> State a c -> (State (a,b) c), which is of course a special case of the above. This matches 'first' on Data.Bifunctor, but State is not a Bifunctor. Nor a Profunctor, AFAIK. Use case: a Stateful computation where a local sub-computation needs more (local) state that will be, in-time, de-allocated. I guess the usual solution is probably to use 2 stacked State, but I'm curious if there's another way. Jacques

4 4

Summer internship with a Haskell-related project (DAAD Rise Germany)
by Niels Bunkenburg 19 Nov '19

19 Nov '19

My department (PL and compiler construction) at the University of Kiel, Germany, offers a summer internship in 2020 sponsored by DAAD Rise Germany [1]. The topic of the project is verification of effectful Haskell programs in Coq. For a brief overview of the internship and the topic, please have a look at the project page [2]. We'd be very happy to host a motivated student who likes working with our haskell-to-coq compiler. Depending on personal interests, the focus of the internship can be the compiler itself or its output and the Coq framework for reasoning about the generated code. Previous knowledge of Coq is not required! If you have any questions beforehand, feel free to reply directly or email us at the addresses listed on the project page. The program funding is based on the number of applications, so please spread the news to your colleagues, students or classmates! Best regards, Niels [1] https://www.daad.de/rise/en/rise-germany/find-an-internship/ [2] https://bunkenburg.net/projects/2019-11-01-daad-rise.html

1 0

[Job] PureScript and Haskell, Tokyo or remote
by Ramin Honary 19 Nov '19

19 Nov '19

*[Job] PureScript and Haskell, Tokyo or remote* Cross Compass <https://www.cross-compass.com/en> in Tokyo is hiring programmers to build a data science IDE on top of JupyterLab <https://jupyterlab.readthedocs.io/en/stable/> , with a Haskell backend and a PureScript/React frontend. The JupyterLab stack is new and we're building new technology. This is a small team and we want to add generalists to work full-time. We are looking for candidates with these areas of interest and experience. - Browser-based GUI applications, especially React and PureScript - Functional programming, especially Haskell - Devops, especially Docker and Nix - Python and the Jupyter ecosystem - Machine learning and data science *About Cross Compass* Cross Compass is a Japanese AI consultancy founded in 2015 in Tokyo <https://goo.gl/maps/79wQbmfbGYgLZgYd9>. It is a leader in AI for manufacturing and industrial robotics with 80~100 projects per year. There are 66 employees (43 engineers), and the office conversation is about half Japanese, half English, with 15 nationalities represented among our staff. The number of self-described Haskellers at Cross Compass currently stands at 4 in Tokyo and 2 remote. github.com/xc-jp - Ramin Honary https://github.com/RaminHAL9001 <https://github.com/RaminHAL9001> - Dennis Gosnell https://github.com/cdepillabout <https://github.com/cdepillabout> - Jonas Carpay https://github.com/jonascarpay <https://github.com/jonascarpay> - Viktor Kronvall https://github.com/considerate <https://github.com/considerate> - Robert Prije https://github.com/rprije <https://github.com/rprije> - James Brock https://github.com/jamesdbrock <https://github.com/jamesdbrock> *Application* We would like to see examples of how you work, so if you have any work published on the internet, please tell us where to look for it, and explain what is interesting about it. Please apply by email to recruit(a)cross-compass.com <recruit(a)cross-compass.com?subject=Programmer+Data+Science+IDE+RECR-371> and include the following: - Highlights of work history - Highlights of education history - Open source software links - Papers, articles, social media, anything which reflects well on you - Request to work in Tokyo office or remote If you want to talk about this position or anything else, please email me at james.brock(a)cross-compass.com. Salary will be based on experience and shall be determined by market pay rates for programming positions in Tokyo. The application process will include a one month trial period. Remote work is possible but we prefer candidates who live, or want to live, in Tokyo, for a larger interaction with our teams. We provide visa sponsorship.

1 0

Reverse of -ddump-splices
by Markus Läll 19 Nov '19

19 Nov '19

Hi list! Is it so that there is no reverse for -ddump-splices? In ghci I can set it with :set -ddump-splices and it turns on, but adding "no" to the flag appears not to work. Found this https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/flags.html so probably there is no reverse? -- Markus Läll

4 6

monoid fold concurrently
by PICCA Frederic-Emmanuel 16 Nov '19

16 Nov '19

Hello, I would like to create a fucntion whcih does mkCube :: [IO a] -> IO a mkCube = ... I want to fold all this concurrently in order to obtain the final a I have a function like this merge :: a -> a -> IO a in order to sort of merge two a into another one. I did not found something like this on hoogle. so I would like your advices in order to write mkCube Thanks Frederic

2 7

FLOPS 2020: DEADLINE EXTENSION (abstract 22 Nov, full paper 29 Nov)
by Shin-Cheng Mu 16 Nov '19

16 Nov '19

FINAL Call For Papers (*** DEADLINE EXTENSION ***) FLOPS 2020: 15th International Symposium on Functional and Logic Programming In-Cooperation with ACM SIGPLAN =============================== 23-25 April, 2020, Akita, Japan https://www.ipl.riec.tohoku.ac.jp/FLOPS2020/ Writing down detailed computational steps is not the only way of programming. An alternative, being used increasingly in practice, is to start by writing down the desired properties of the result. The computational steps are then (semi-)automatically derived from these higher-level specifications. Examples of this declarative style of programming include functional and logic programming, program transformation and rewriting, and extracting programs from proofs of their correctness. FLOPS aims to bring together practitioners, researchers and implementors of the declarative programming paradigm, to discuss mutually interesting results and common problems: theoretical advances, their implementations in language systems and tools, and applications of these systems in practice. The scope includes all aspects of the design, semantics, theory, applications, implementations, and teaching of declarative programming. FLOPS specifically aims to promote cross-fertilization between theory and practice and among different styles of declarative programming. *** Scope *** FLOPS solicits original papers in all areas of the declarative programming: * functional, logic, functional-logic programming, rewriting systems, formal methods and model checking, program transformations and program refinements, developing programs with the help of theorem provers or SAT/SMT solvers, verifying properties of programs using declarative programming techniques; * foundations, language design, implementation issues (compilation techniques, memory management, run-time systems, etc.), applications and case studies. FLOPS promotes cross-fertilization among different styles of declarative programming. Therefore, research papers must be written to be understandable by the wide audience of declarative programmers and researchers. In particular, each submission should explain its contributions in both general and technical terms, clearly identifying what has been accomplished, explaining why it is significant for its area, and comparing it with previous work. Submission of system descriptions and declarative pearls are especially encouraged. *** Submission *** Submissions should fall into one of the following categories: * Regular research papers: they should describe new results and will be judged on originality, correctness, and significance. * System descriptions: they should describe a working system and will be judged on originality, usefulness, and design. * Declarative pearls: new and excellent declarative programs or theories with illustrative applications. System descriptions and declarative pearls must be explicitly marked as such in the title. Submissions must be unpublished and not submitted for publication elsewhere. Work that already appeared in unpublished or informally published workshops proceedings may be submitted. See also ACM SIGPLAN Republication Policy, as explained on the web at http://www.sigplan.org/Resources/Policies/Republication. Submissions must be written in English and can be up to 15 pages excluding references, though system descriptions and pearls are typically shorter. The formatting has to conform to Springer's guidelines. Regular research papers should be supported by proofs and/or experimental results. In case of lack of space, this supporting information should be made accessible otherwise (e.g., a link to an anonymized Web page or an appendix, which does not count towards the page limit). However, it is the responsibility of the authors to guarantee that their paper can be understood and appreciated without referring to this supporting information; reviewers may simply choose not to look at it when writing their review. FLOPS 2020 will employ a double-blind reviewing process. To facilitate this, submitted papers must adhere to two rules: 1. author names and institutions must be omitted, and 2. references to authors' own related work should be in the third person (e.g., not "We build on our previous work..." but rather "We build on the work of..."). The purpose of this process is to help the reviewers come to a judgement about the paper without bias, not to make it impossible for them to discover the authors if they were to try. Nothing should be done in the name of anonymity that weakens the submission or makes the job of reviewing the paper more difficult (e.g., important background references should not be omitted or anonymized). In addition, authors should feel free to disseminate their ideas or draft versions of their paper as they normally would. For instance, authors may post drafts of their papers on the web or give talks on their research ideas. Papers should be submitted electronically at https://easychair.org/conferences/?conf=flops2020 Springer Guidelines https://www.springer.com/gp/computer-science/lncs/conference-proceedings-gu… *** Proceedings *** The proceedings will be published by Springer International Publishing in the Lecture Notes in Computer Science (LNCS) series (www.springer.com/lncs) *** Important Dates *** [EXTENDED] 22 November 2019 (AoE): Abstract submission [EXTENDED] 29 November 2019 (AoE): Submission deadline [EXTENDED] 31 January 2020: Author notification [EXTENDED] 20 February 2020: Camera ready due 23-25 April 2020: FLOPS Symposium *** Programming Comittee *** Elvira Albert Universidad Complutense de Madrid María Alpuente Universitat Politècnica de València Edwin Brady University of St Andrews Michael Hanus CAU Kiel Nao Hirokawa JAIST Zhenjiang Hu Peking University John Hughes Chalmers University of Technology Kazuhiro Inaba Google Shin-Ya Katsumata National Institute of Informatics Ekaterina Komendantskaya Heriot-Watt University Leonidas Lampropoulos University of Pennsylvania Akimasa Morihata The University of Tokyo Shin-Cheng Mu Academia Sinica Keisuke Nakano Tohoku University (co-chair) Koji Nakazawa Nagoya University Enrico Pontelli New Mexico State University Didier Remy INRIA Ricardo Rocha University of Porto Konstantinos Sagonas Uppsala University (co-chair) Ilya Sergey Yale-NUS College Kohei Suenaga Kyoto University Tachio Terauchi Waseda University Kazushige Terui Kyoto University Simon Thompson University of Kent Philip Wadler, University of Edinburgh *** Organizers *** Keisuke Nakano Tohoku University, Japan (PC Co-Chair, General Chair) Kostis Sagonas Uppsala University, Sweden (PC Co-Chair) Kazuyuki Asada Tohoku University, Japan (Local Co-Chair) Ryoma Sin'ya Akita University, Japan (Local Co-Chair) Katsuhiro Ueno Tohoku University, Japan (Local Co-Chair) *** Contact Address *** flops2020 _AT_ easychair.org

1 0

GHC API: parsing as much as I can
by Artem Pelenitsyn 15 Nov '19

15 Nov '19

Hello Cafe, I need an advice on how to use GHC API to parse big collections of Haskell source files. Say, I want to collect ASTs of everything that is on Hackage. I downloaded the whole Hackage (latest versions only) and have it locally now. I tried simple advice found in the Parse module documentation: https://hackage.haskell.org/package/ghc-8.6.5/docs/Parser.html runParser :: DynFlags -> String -> P a -> ParseResult a runParser flags str parser = unP parser parseState where filename = "<interactive>" location = mkRealSrcLoc (mkFastString filename) 1 1 buffer = stringToStringBuffer str parseState = mkPState flags buffer location It mostly works: 75% of .hs files on Hackage seem to parse fine. I looked into the rest 25% and noticed that this snippet can't handle files using GHC extensions such as RankNTypes, TemplateHaskell, BangPatterns, etc.when given the default DynFlags. This leads me to the question of how should I initialize DynFlags? Currently, I use this for getting DynFlags: initDflags :: IO DynFlags initDflags = do let ldir = Just libdir mySettings <- initSysTools ldir myLlvmConfig <- initLlvmConfig ldir initDynFlags (defaultDynFlags mySettings myLlvmConfig) I understand that simple parsing of individual files can't take into account extensions activated inside .cabal files. But I'd expect that it should be possible to, at least, consider the extensions mentioned in the LANGUAGE pragmas. Currently, this isn't happening. Any suggestions on how to achieve this are welcomed. I probably won't get to parsing 100% of Hackage, but I'd hope for better than the current 75%. -- Best wishes, Artem

2 2

ANN: semialign-extras-0.1.0.0, and a request for help
by Jack Kelly 15 Nov '19

15 Nov '19

I have just pushed an initial release of semialign-extras[1] to Hackage. semialign-extras aims to collect interesting abstractions/operations that: 1. Build on top of (at least) the Semialign typeclass, or related classes from the semialign universe; and 2. Do not belong inside other packages in the semialign universe. PRs that serve these goals are most welcome, as are GitHub issues[2]. Currently, there are two modules: * Data.Semialign.Diff has diffing/patching for Semialigns; and * Data.Semialign.Merge has a collection of merge operations for Semialigns which are also Filterable/Traversable/Witherable Request for help: The functions in Data.Semialign.Diff work across a lot of types, but are are often not the most efficient way to diff. There is a high-performance merge API for Data.Map.Map in Data.Map.Merge.Lazy[3], and it would be great to have some rewrite rules that took advantage of this. I have been able to write rules that GHC accepts, but not make them actually fire[4]. I'd be grateful for any assistance people can provide. Best, -- Jack [1]: http://hackage.haskell.org/package/semialign-extras-0.1.0.0 [2]: https://github.com/qfpl/semialign-extras [3]: https://hackage.haskell.org/package/containers-0.6.0.1/docs/Data-Map-Merge-… [4]: https://github.com/qfpl/semialign-extras/issues/3

1 0

Re: [Haskell-cafe] Explicit approach to lazy effects For probability monad?
by Olaf Klinke 14 Nov '19

14 Nov '19

Hi Benjamin, Your example code seems to deal with two distinct types: The do-notation is about the effects monad (on the random number generator?) and the `sample` function pulls whatever representation you have for an actual probability distribution into this effect monad. In my mental model, the argument to `sample` represents a function Double -> x that interprets a number coming out of the standard random number generator as an element of type x. I suggest to consider the following two properties of the mathematical probability monad (a.k.a. the Giry monad), which I will use as syntactic re-write rules in your modeling language. The first property is Fubini's Theorem. In Haskell terms it says that for all f, a :: m x and b :: m y the two terms do {x <- a; y <- b; f x y} do {y <- b; x <- a; f x y} are semantically equivalent. (For state monads, this fails.) Monads where this holds are said to be commutative. If you have two urns, then drawing from the left and then drawing from the right is the same as first drawing from the right and then drawing from the left. Using Fubini, we can swap the first two lines in your example: model = do cond <- bernoulli 0.5 x <- normal 0 1 return (if cond == 1 then x else 0) This desugars to bernoulli 0.5 >>= (\cond -> normal 0 1 >>= (\x -> return (if cond == 1 then x else return 0))) bernoulli 0.5 >>= (\cond -> fmap (\x -> if cond == 1 then x else 0) (normal 0 1)) The second property is a kind of lazyness, namely fmap (const x) and return are semantically equivalent. which holds for mathematical distributions (but not for state monads). Now one could argue that in case cond == 0 the innermost function is constant in x, in which case the whole thing does not depend on the argument (normal 0 1). The Lemma we need here is semantic equivalence of the following two lambda terms. \cond -> \x -> if cond == 1 then x else 0 \cond -> if cond == 1 then id else const 0 If the above is admissible then the following syntactic transformation is allowed: model = do cond <- bernoulli 0.5 if cond == 1 then normal 0 1 else return 0 which makes it obvious that the normal distribution is only sampled when needed. But I don't know whether you would regard this as the same model. Notice that I disregarded your `sample` function. That is, my monadic language is the monad of probabilites, not the monad of state transformations of a random number generator. Maybe you can delay using the random number generator until the very end? I don't know the complete set of operations your modeling language sports. If that delay is possible, then maybe you can use a monad that has the above two properties (e.g. a reader monad) and only feed the random numbers to the final model. As proof of concept, consider the following. type Model = Reader Double model :: Model Int model = do x <- reader (\r -> last [1..round (recip r)]) cond <- reader (\r -> r > 0.5) return (if cond then x else 0) runReader model is fast for very small inputs, which would not be the case when the first line was always evaluated. Cheers, Olaf

3 5

Statically checked overloaded strings
by Christopher Done 14 Nov '19

14 Nov '19

Hi all, I just came up with this neat trick for adding static checks to overloaded strings: https://gist.github.com/chrisdone/809296b769ee36d352ae4f8dbe89a364 Hope it's helpful. I wonder whether the GHC devs would be open to a small patch to permit: $$"..." :-) Cheers, Chris

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

Second call for draft papers for TFPIE 2020 (Trends in Functional Programming in Education)
by Jurriaan Hage 14 Nov '19

14 Nov '19

Hello, Please, find below the second call for draft papers for TFPIE 2020. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Chair of TFPIE 2020 ======================================================================== TFPIE 2020 Call for papers http://www.staff.science.uu.nl/~hage0101/tfpie2020/index.html February 12th 2020, Krakow, Poland (co-located with TFP 2020 and Lambda Days) TFPIE 2020 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: FP and beginning CS students FP and Computational Thinking FP and Artificial Intelligence FP in Robotics FP and Music Advanced FP for undergraduates FP in graduate education Engaging students in research using FP FP in Programming Languages FP in the high school curriculum FP as a stepping stone to other CS topics FP and Philosophy The pedagogy of teaching FP FP and e-learning: MOOCs, automated assessment etc. Best Lectures - more details below In addition to papers, we are requesting best lecture presentations. What's your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. The length of the presentation should be comparable to that of a paper. On top of the lecture itself, the presentation can also provide commentary on the lecture. Submissions Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 20 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website. Papers and abstracts can be submitted via easychair at the following link: https://easychair.org/conferences/?conf=tfpie2020 . After the workshop, presenters will be invited to submit (a revised version of) their article for review. The PC will select the best articles that will be published in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. Dates Submission deadline: January 14th 2020, Anywhere on Earth. Notification: January 17th 2020 TFPIE Registration Deadline: January 20th 2020 Workshop: February 12th 2020 Submission for formal review: April 19th 2020, Anywhere on Earth. Notification of full article: June 6th 2020 Camera ready: July 1st 2020 Program Committee Olaf Chitil - University of Kent Youyou Cong - Tokyo Institute of Technology Marko van Eekelen - Open University of the Netherlands and Radboud University Nijmegen Jurriaan Hage (Chair) - Utrecht University Marco T. Morazan - Seton Hall University, USA Sharon Tuttle - Humboldt State University, USA Janis Voigtlaender - University of Duisburg-Essen Viktoria Zsok - Eotvos Lorand University Note: information on TFP is available at http://www.cse.chalmers.se/~rjmh/tfp/

1 0

Code coverage: mark certain function calls as covered
by Özgür Akgün 13 Nov '19

13 Nov '19

This may sound like a bizarre request, but I feel I can't be the only one. I have a function called "bug". This is essentially a special case of "error", but I am disciplined and I only use this function to mark parts of my code I believe are unreachable. So something like: data Term = X ... | Y ... | Z ... -- the argument can only be X or Y in this part of the program f :: Term -> ... f (X ...) = ... f (Y ...) = ... f Z{} = bug "This should never happen (in f)" You might hate this style of programming, and frankly I am not a fan either. But sometimes we have to write partial functions and I am at least trying to mark the cases explicitly in these cases. So this is my question: if I did a good job and if the Z case above is indeed unreachable, the code coverage report will always flag it as uncovered and in the overall report this will make it harder for me to see the parts of my code which aren't covered and should be. I'd like a way of marking (= generating a tick for?) every call to this function bug as covered. Please let me know if there is a better place to ask this question. I checked and hpc <http://hackage.haskell.org/package/hpc>'s issue tracker is shared with GHC's and I wasn't sure if they'd appreciate a question there. -- Özgür Akgün

2 1

First release of sexpresso
by Vincent Archambault-Bouffard 11 Nov '19

11 Nov '19

Hello, I'm pleased to announce the first release of the sexpresso [0] library on Hackage. sexpresso is a library to parse, print and work with S-expression. You can for example : - Customize the opening and closing tag, usually '(' and ')'. - Specify if space is needed between atoms (or between only a subset of atoms) - The datatype for S-expression (SExpr) has a extra parameter to make parsing, working and printing with multiple "type" of S-expression, like Scheme list (...) and Scheme vector #(....), easier - Do much more ... read the doc on Hackage or the README on github [1] ! I plan to improve the printer and add recursive scheme soon. [0] http://hackage.haskell.org/package/sexpresso [1] https://github.com/archambaultv/sexpresso Vincent Archambault

2 1

Help wanted: Postfix admin guru for Haskell.org
by Gershom B 10 Nov '19

10 Nov '19

We've been getting increasing amounts of bounces and dropped mail for haskell.org emails (things sent hackage trustees, things sent from our wiki and hackage servers, etc). We _mainly_ have kept things working, but it looks like policies have been amped up in terms of requiring various measures. Additionally, there's something about reverse dns and valid hostnames that seems to not be configured correctly, according to mxtoolbox. Along with all that, we'd really like to migrate the mail infrastructure to our new packet servers, away from rackspace. As such, we could use some concentrated help from someone familiar with maintaining and administering postfix servers, if someone is up to volunteer for the task. Thanks! --Gershom

2 1

Type class constraints in rewrite rules
by Janus Troelsen 09 Nov '19

09 Nov '19

Hi, I am trying to speed up some code using the Simplicity library by roconnor. He suggested I apply a rewrite rule to implement the full-adder using Haskell's addition: > fullAdder @(Kleisli m) w > into > Kleisli (\((a,b),c) -> return $ let sum = fromWord w a + fromWord w b + fromWord1 c in (toBit (sum >= 2 ^ wordSize w), toWord w sum)) I turned that description into a rewrite rule by prepending "forall m w.". But that results in "Forall'd variable ‘m’ does not appear on left hand side" and "Not in scope: type variable ‘m’" (which seems contradictory?) So I thought, OK, typically Type Applications are not necessary, I will just remove it. So the RULE becomes: "fullAdderOpt" forall w. fullAdder w = Kleisli (\((a,b),c) -> return $ let sum = fromWord w a + fromWord w b + fromWord1 c in (toBit (sum >= 2 ^ wordSize w), toWord w sum)) but compiling that, I get: > Could not deduce (Monad m) arising from a use of ‘return’". > Possible fix: add (Monad m) to the context of the RULE "fullAdderOpt" OK, that must mean I should prepend "(Monad m) =>". I tried inserting that either before or after the forall, but both variants are parse errors. So I am suspecting a GHC bug, since I was suggested to do something that doesn't parse. But really, I am just wondering how to make a rewrite rule that does what roconnor suggested. The full source code of the final version is here: https://hushfile.it/api/file?fileid=5dc706576e329 Regards, Janus

1 0

ANN: ban-instance-0.1.0.1
by Jack Kelly 08 Nov '19

08 Nov '19

I have just pushed an initial release of ban-instance[1] to Hackage. ban-instance uses template haskell to generate compile errors for typeclass instances that should not exist: -- Declare that Foo should never have a ToJSON instance $(banInstance [t|ToJSON Foo|] "why ToJSON Foo should never be defined") The custom errors then say why an instance is banned: • Attempt to use banned instance (ToJSON Foo) Reason for banning: why ToJSON Foo should never be defined Instance banned at [moduleName] filePath:lineNumber We have found this useful to prevent definition of ToJSON/FromJSON instances on core data types, as this forces programmers to instead place the serialisation instances on newtypes at the serialisation boundary. GitHub issues and PRs are welcome[2]. In particular, there are currently a few limitations: 1. There is currently no support for classes with associated types or associated data types; 2. It would be great to generate haddocks for banned instances, marking them as such; and 3. Type quotations [t|...|] do not support free variables (GHC#5616). Nevertheless, I hope that it is useful. Best, -- Jack [1]: http://hackage.haskell.org/package/ban-instance-0.1.0.1 [2]: https://github.com/qfpl/ban-instance/

1 0

[ANN] Keycloak-hs
by Corentin Dupont 07 Nov '19

07 Nov '19

Hello, I'm very proud to announce the release of Keycloak-hs, a library to access Keycloak: http://hackage.haskell.org/package/keycloak-hs. Keycloak (www.keycloak.org) is a tool allowing to authenticate users and protect your API resources. I included a tutorial in the README file. Keycloak as many many features, so this library will evolve to cover more. Help/PRs are welcome! Cheers! Corentin

1 0

Explicit approach to lazy effects For probability monad?
by Benjamin Redelings 07 Nov '19

07 Nov '19

Hi, I'm wondering if people could point me to some background on explicitly representing lazy effects in Haskell? The only effect I am concerned about at this point is `seq`. If there is a way to do this with monads, that would be great. (I know that a lot of people hate lazy effects. However, I think this is an orthogonal issue to the question of how to *represent* lazy effects explicitly.) As background, I'm using a lazy probability monad where random sampling is done with unsafeInterleaveST/IO (or something similar), so that random variables are only sampled if they are actually used: model = do x <- sample $ normal 0 1 -- the interpreter does `unsafeInterleaveIO` to implement 'sample' cond <- sample $ bernoulli 0.5 let y = if cond == 1 then x else 0 return y Here, x is only sampled if cond==1. This has a lot of benefits in procedures like Markov chain Monte Carlo. I initially thought that I could model lazy effects by mapping a -> (a,state) as in the ST monad. However, it seems like lazy effects basically require allowing forked state threads to join CONDITIONALLY on if a value is used/forced, and I don't see how to do that without a source-to-source transformation of functions. It seems like lazy effects require tracking state within each closure, and not globally within the monad interpreter. It kind of seems like this can't work if >>= has type 'm a -> (a -> m b) -> mb', assuming m a = (a,state). The second argument needs to have type (m a -> m b) instead of (a -> m b), since the computation needs to have access to the state produced by the first "m a" computation, in order to (optionally) depend on the state thread for first computation. Does this make any sense? I don't know the literature in this area. Q1. Is there a nice way of representing lazy effects that someone could point me to? Q2. Alternatively, is there a proof that either (i) there is not a monadic way to represent lazy effects, or (ii) fmap f requires a source-to-source transformation (for example to explicitly join state threads on strict operations like ($) and case). -BenRI P.S. As even more background, I'm using a probability monad that allows you to e.g. generate an infinite list of random variables, and only instantiate the ones that are looked at: model = do n <- sample $ geometric 0.5 ys <- sample $ list (repeat $ normal 0.0 1.0) zs <- take n ys return (sum zs) Here the number of random variables (n) can change over time, and I ultimately want effects to happen when they are instantiated. There is a brief overview at http://www.bali-phy.org/models.php

2 2

Performance difference parallel 'toString'
by Donald Cordes 06 Nov '19

06 Nov '19

Hi everybody, I'm trying to squeeze more performance out of Haskell, and I'm hoping someone can help me understand why the following two pieces of code have different performance. In particular, I find that the apparently 'more parallel' version of the code performs worse. Quick description of the code: basically it solves the following problem [https://www.spoj.com/problems/PALIN/] The input is a set of huge integer numbers. For each number, print the smallest 'palindrome' that is larger. A palindrome is a number for which when you reverse its digits you end up with the same number. The code uses 'parBuffer' to do the calculations in parallel. Below is high-level description of the steps of each version: Version 1 [palin.parfromstring.hs]: 1. Read the input numbers as strings into a list 2. Perform the following calculation for each number (the steps for this calculation run in sequence, the entire calculation runs in parallel w.r.t. different numbers): 2.1 Convert from string to array of digits 2.2 Calculate the palindrome in-place The result of step 2 is a list of digit-arrays. That concludes the parallel step. 3. For each palindrome, convert it to a string and print it. Version 2 [palin.parfromstringtostring.hs]: 1. Same as above 2.1 Same as above 2.2 Same as above 2.3 Convert the palindrome to a string 3. For each string, print it. I'd expect that version 2 is faster than version 1 because it's doing the conversion back to string also in parallel, but on a set of 50 numbers it's surprisingly ~750ms slower on my computer. I see that the GC is doing a lot more copying for version 2 (1GB more than version 1), but I don't really understand what I'm looking it. :) How can one best think about getting more performance out of parallelism in Haskell? As in, what are some good rules of thumb by which one can decide 'parallelize this, don't parallelize that'? Attached you can find the event logs for ThreadScope and full code for each version. The code is almost identical, so attached is also the diff between the two. Thanks in advance

1 0

Re: [Haskell-cafe] [FP] Postdoc position at University of Bristol in functional programming
by Meng Wang 04 Nov '19

04 Nov '19

Dear Haskellers, The programming languages group at Bristol has an open post doc position in the area of functional programming. Haskell programmers are particularly welcome. Please pass it on to anyone who might be interested. Thanks! Best regards, Meng Meng Wang, PhD (Oxon) Senior Lecturer (Associate Professor) Department of Computer Science University of Bristol Merchant Venturers Building, Woodland Road, Clifton BS8 1UB +44 (0) 117 954 5145 meng.wang(a)bristol.ac.uk We are looking for an enthusiastic, self-motivated individual to contribute to an EPSRC-funded project, which aims to design programming languages that guarantee strong properties, and the application of them. The post holder will be based in the programming languages group at the University of Bristol Computer Science Department, which consists of three academics, two PDRAs, and a number of PhD students. You will also be working with a network of partners from Oxford, Edinburgh, Tohoku Japan, Chalmers Sweden, and industrial partner DFINITY Foundations providing expertise on WebAssembly. You should have a PhD in programming languages, or a closely related field. This post is available immediately and is offered on a full-time based for an initial term of three years. Appointment at a higher salary point than grade I is possible based on relevant experience. Informal enquiries should be addressed to Dr. Meng Wang (meng.wang(a)bristol.ac.uk) For more details about this position, please see: http://www.bristol.ac.uk/jobs/find/details.html?nPostingID=57894&nPostingTa… Deadline: 25 November 2019

1 0

2019 State of Haskell Survey
by Taylor Fausak 04 Nov '19

04 Nov '19

Hi friends! I am excited to announce the third annual State of Haskell Survey. I’d appreciate it if you could take a few minutes to fill it out. Thanks! https://haskellweekly.news/survey/2019.html

4 4

Journal of Functional Programming - Call for PhD Abstracts
by Graham Hutton 04 Nov '19

04 Nov '19

============================================================ CALL FOR PHD ABSTRACTS Journal of Functional Programming Deadline: 30th November 2019 http://tinyurl.com/jfp-phd-abstracts ============================================================ PREAMBLE: Many students complete PhDs in functional programming each year. As a service to the community, twice per year the Journal of Functional Programming publishes the abstracts from PhD dissertations completed during the previous year. The abstracts are made freely available on the JFP website, i.e. not behind any paywall. They do not require any transfer of copyright, merely a license from the author. A dissertation is eligible for inclusion if parts of it have or could have appeared in JFP, that is, if it is in the general area of functional programming. The abstracts are not reviewed. Please submit dissertation abstracts according to the instructions below. We welcome submissions from both the PhD student and PhD advisor/supervisor although we encourage them to coordinate. ============================================================ SUBMISSION: Please submit the following information to Graham Hutton <graham.hutton(a)nottingham.ac.uk> by 30th November 2019: o Dissertation title: (including any subtitle) o Student: (full name) o Awarding institution: (full name and country) o Date of PhD award: (month and year; depending on the institution, this may be the date of the viva, corrections being approved, graduation ceremony, or otherwise) o Advisor/supervisor: (full names) o Dissertation URL: (please provide a permanently accessible link to the dissertation if you have one, such as to an institutional repository or other public archive; links to personal web pages should be considered a last resort) o Dissertation abstract: (plain text, maximum 350 words; you may use \emph{...} for emphasis, but we prefer no other markup or formatting; if your original abstract exceeds the word limit, please submit an abridged version within the limit) Please do not submit a copy of the dissertation itself, as this is not required. JFP reserves the right to decline to publish abstracts that are not deemed appropriate. ============================================================ PHD ABSTRACT EDITOR: Graham Hutton School of Computer Science University of Nottingham Nottingham NG8 1BB United Kingdom ============================================================ This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please contact the sender and delete the email and attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. Email communications with the University of Nottingham may be monitored where permitted by law.

1 0

hindent: maintainer needed
by Christopher Done 03 Nov '19

03 Nov '19

Hi all, I'm sunsetting my maintenance of hindent. It basically does what I want and has done for the last four years. I've put enough hours into this project that I'm ready to move onto new things. The approach of using GHC to format code is already being explored by at least two other projects: * brittany <http://hackage.haskell.org/package/brittany> * ormolu <https://github.com/tweag/ormolu> So if you still want hindent to continue being updated, I suggest you take over as maintainer, either as a group or an individual. Feel free to comment here. I'm happy to create an organization and move the project into it. In the absence of anyone taking over, the GitHub project will be archived on Jan 31st. By that point, the issues/PRs will be lost. There is a related GitHub issue here: <https://github.com/chrisdone/hindent/issues/557> Cheers, Chris

2 1

Call for maintainer: formatting package
by Christopher Done 03 Nov '19

03 Nov '19

Hi all, The formatting package needs a maintainer. I made this package 6 years ago based on the HoleyMonoid package's idea. I thought it would become a staple package for me. Since then, I have basically never actually used it in a project. It turns out, I don't like the printf-style of doing printing at all, and prefer to just manually append things. As such, it doesn't make sense for me to maintain this package. Feel free to comment here or on the GitHub issue if you are interested: https://github.com/chrisdone/formatting/issues/58 Cheers, Chris

1 0

Expired certificate for prime.haskell.org
by Simon Jakobi 02 Nov '19

02 Nov '19

Hi! I just wanted to give someone a link to the Semigroup-Monoid-proposal, but couldn't open the page in Chromium: https://prime.haskell.org/wiki/Libraries/Proposals/SemigroupMonoid There's already a short email thread regarding the issue from April on the haskell-prime mailing list: https://mail.haskell.org/pipermail/haskell-prime/2019-April/004448.html It would be nice if proposals like the SMP remained accessible! Cheers, Simon

2 3

How to build a horse with Haskell (comic extension)
by J Ho 31 Oct '19

31 Oct '19

There was this comics “how to build a horse” with different languages. I’ve always felt Haskell was missing. Found this on Quora - https://www.quora.com/How-do-you-build-a-horse-with-the-Haskell-programming… How to build a horse with Haskell. Building just a horse is boring, so you generalize it to a spherical horse in vacuum that can represent other animals sufficiently well. It takes 5 years, 43 research papers and only 3 people in the world can ride it (including SPJ). You build a horse. It’s fast, but lazy. You build a beautiful, friendly horse. You call it Monadic Quadro-pedo-functorial Transporter. People are afraid to touch it and it dies of loneliness. You build something that is Maybe a horse. All your horses come in boxes with bottom. You were a java programmer so you build a horse factory. It gives you Either a horse or a terrible runtime abomination. You build an existential horse. You can’t see or access its hoofs, tail, back, anything. It just sort of sits there and stares at you. You build an infinitely large horse. You can still ride it, because it’s lazy (it just sits there, just like the existential, and you crawl on its back slowly). You tease Java programmers who can’t possibly ride infinite horses. You build an even faster horse that is unboxed. You notice it is eager. You build a higher-kinded Horsificator. It turns anything else into horses. data Horsificator a = Horse a | Abomination You want to ride a rhino, but they normally would kill you. You build a horse typeclass. You make rhinos an instance of Horse. Polymorphic domestication!

1 0

Call for Workshop Proposals: ICFP 2020
by Sam Tobin-Hochstadt 30 Oct '19

30 Oct '19

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS ICFP 2020 25th ACM SIGPLAN International Conference on Functional Programming August 23 - 28, 2020 Jersey City, NJ, US https://icfp19.sigplan.org/ The 25th ACM SIGPLAN International Conference on Functional Programming will be held in Jersey City, New Jersey on August 23-28, 2020. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for workshops (and other co-located events, such as symposiums) to be affiliated with ICFP 2020 and sponsored by SIGPLAN. These events should be less formal and more focused than ICFP itself, include sessions that enable interaction among the attendees, and foster the exchange of new ideas. The preference is for one-day events, but other schedules can also be considered. The workshops are scheduled to occur on August 23rd (the day before ICFP) and 27-28th of August (the two days after ICFP). ---------------------------------------------------------------------- Submission details Deadline for submission: November 15, 2019 Notification of acceptance: December 13, 2019 Prospective organizers of workshops or other co-located events are invited to submit a completed workshop proposal form in plain text format to the ICFP 2020 workshop co-chairs (Jennifer Hackett and Leonidas Lampropoulos) via email to icfp-workshops-2020(a)googlegroups.com by November 15, 2019. (For proposals of co-located events other than workshops, please fill in the workshop proposal form and just leave blank any sections that do not apply.) Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by December 13, 2019, and if successful, depending on the event, they will be asked to produce a final report after the event has taken place that is suitable for publication in SIGPLAN Notices. The proposal form is available at: http://www.icfpconference.org/icfp2020-files/icfp20-workshops-form.txt Further information about SIGPLAN sponsorship is available at: http://www.sigplan.org/Resources/Proposals/Sponsored/ ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2020 organizing committee, together with the members of the SIGPLAN executive committee. Workshop Co-Chair: Jennifer Hackett (University of Nottingham) Workshop Co-Chair: Leonidas Lampropoulos (University of Maryland) General Chair: Stephanie Weirich (University of Pennsylvania) Program Chair: Adam Chlipala (MIT) ---------------------------------------------------------------------- Further information Any queries should be addressed to the workshop co-chairs (Jennifer Hackett and Leonidas Lampropoulos), via email to icfp-workshops-2020(a)googlegroups.com.

1 0

A Haskell meetup in San Francisco today
by Dimitri DeFigueiredo 29 Oct '19

29 Oct '19

After a long wait, there's a haskell meetup in San Francisco today. https://www.meetup.com/Bay-Area-Haskell-Users-Group/events/265110367/ Exciting! :-) Dimitri -- 2E45 D376 A744 C671 5100 A261 210B 8461 0FB0 CA1F

1 0

ANN: reflex-basic-host-0.2.0.1, reflex-backend-socket-0.2.0.0
by Jack Kelly 29 Oct '19

29 Oct '19

I have just pushed two packages to hackage: 1. reflex-basic-host-0.2.0.1[1], a reflex host library for backend work, and 2. reflex-backend-socket-0.2.0.0[2] a reflex-flavoured wrapper around TCP sockets. The most important changes to reflex-basic-host are: * Hosts no longer needlessly fork a thread, meaning that it is safe to call native code which expects all library calls to come from a common thread; and * Each host runs in a separate Reflex timeline, which makes it possible to run multiple Reflex hosts in parallel. There is an example[3] on GitHub demonstrating two hosts passing messages to each other. I hope people find it useful. GitHub issues and PRs welcome[4, 5]. Best, -- Jack [1] https://hackage.haskell.org/package/reflex-basic-host-0.2.0.1 [2] https://hackage.haskell.org/package/reflex-backend-socket-0.2.0.0 [3] https://github.com/qfpl/reflex-basic-host/blob/master/example/Multithread.hs [4] https://github.com/qfpl/reflex-basic-host [5] https://github.com/qfpl/reflex-backend-socket

1 0

Functional Conference 2019 with Edward Kmett keynote | Bengaluru, 13-17 November
by John Sinclair 28 Oct '19

28 Oct '19

Hi haskell-cafe! If you're in India, you'll be interested in Functional Conference 2019. It's an opportunity to meet up with other functional programmers and Haskell users. You'll learn from Edward Kmett who is chairman of the Haskell Core Libraries Committee. He'll be delivering a keynote, a workshop and more. https://confng.in/Kmg8m-Tx Michael Snoyman from Israel will be giving an Applied Haskell workshop. https://confng.in/24haPWyw All up their are 15 sessions covering Haskell to broaden your horizons and deepen your knowledge. Functional Conf is the premiere event for Functional programmers in India. Our goal is to support the community with access to high quality speakers, who are innovating in this field. Learn more about the conference here: https://confng.in/wAQ41Z4q To get 10% off when you register, use the code: FnConf19Dis$ https://twitter.com/FnConf <https://llink.to/?u=https:%2F%2Ftwitter.com%2FFnConf&e=df52b49527f43fa29bda…> https://www.linkedin.com/showcase/functional-conf <https://llink.to/?u=https:%2F%2Fwww.linkedin.com%2Fshowcase%2Ffunctional-co…>

1 0

reading from a unix pipe and then from the user
by Aramís Concepción Durán 27 Oct '19

27 Oct '19

Hello, I'm trying to write a program that first reads input from a pipe and then reads keyboard input from the user (like fzf, the fuzzy finder). Under different circumstances I could open a handle to `/dev/tty` and use the `hGet...` functions from `System.IO` to get the user's keyboard input, but I'm constructing the text user interface with the brick library, which doesn't seem to give my any way to sneak in alternative handles through its application entry point functions. So, what I'm looking for is a function which takes an `IO ()` function like the usual `main` and a `Handle` and turns it into an `IO ()` function that reads from the provided handle instead of `stdin`. Does that make sense? I might be looking for something that doesn't exist. Or I'm lacking the language to get results from a search engine. To illustrate the problem further, here is a condensed brick application: import qualified Brick.Main as Main import qualified Brick.Types as Types import qualified Graphics.Vty as Vty import Brick.AttrMap ( attrMap ) import Brick.Widgets.Core ( str ) type Event = Types.EventM () ( Types.Next () ) main = let app = Main.App { Main.appChooseCursor = Main.neverShowCursor , Main.appHandleEvent = \ _ _ -> Main.halt () :: Event , Main.appStartEvent = pure , Main.appAttrMap = \ _ -> attrMap Vty.currentAttr [] , Main.appDraw = \ _ -> [ str Hit any key to exit. ] } in Main.defaultMain app () How do I get this `main` function to read from a custom handle intead of stdin?

3 4

Munich Haskell Meeting, 2019-10-29 @ 19:30
by Leah Neukirchen 27 Oct '19

27 Oct '19

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Tuesday, October 29 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-oct-2019/ Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

2nd Call for Contributions: BOB 2020 [Feb 28, Deadline Nov 8]
by Stefan Wehr 24 Oct '19

24 Oct '19

BOB Conference 2020 "What happens when we use what's best for a change?" http://bobkonf.de/2020/cfc.html Berlin, February 28 Call for Contributions Deadline: November 8, 2019 You are actively engaged in advanced software engineering methods, implement ambitious architectures and are open to cutting-edge innovation? Attend this conference, meet people that share your goals, and get to know the best software tools and technologies available today. We strive to offer a day full of new experiences and impressions that you can use to immediately improve your daily life as a software developer. If you share our vision and want to contribute, submit a proposal for a talk or tutorial! NOTE: The conference fee will be waived for presenters. Travel expenses will not be covered (for exceptions see "Speaker Grants"). Speaker Grants -------------- BOB has Speaker Grants available to support speakers from groups under-represented in technology. We specifically seek women speakers and speakers who are not be able to attend the conference for financial reasons. Shepherding ----------- The program committee offers shepherding to all speakers. Shepherding provides speakers assistance with preparing their sessions, as well as a review of the talk slides. Topics ------ We are looking for talks about best-of-breed software technology, e.g.: - functional programming - persistent data structures and database - event-based modelling and architectures - types - formal methods for correctness and robustness - abstractions for concurrency and parallelism - metaprogramming - probabilistic programming - math and programming - controlled side effects - beyond REST and SOAP - effective abstractions for data analytics - ... everything really that isn’t mainstream, but you think should be. Presenters should provide the audience with information that is practically useful for software developers. We're especially interested in experience reports. Other topics are also relevant, e.g.: - introductory talks on technical background - overviews of a given field - demos and how-tos Requirements ------------- We accept proposals for presentations of 45 minutes (40 minutes talk + 5 minutes questions), as well as 90 minute tutorials for beginners. The language of presentation should be either English or German. Your proposal should include (in your presentation language of choice): - An abstract of max. 1500 characters. - A short bio/cv - Contact information (including at least email address) - A list of 3-5 concrete ideas of how your work can be applied in a developer's daily life - additional material (websites, blogs, slides, videos of past presentations, …) Submit here: https://bobcfc.active-group.de/en/bob2020/cfp Organisation ------------ - Direct questions to contact at bobkonf dot de - Proposal deadline: November 8, 2019 - Notification: November 22, 2019 - Program: December 6, 2019 Program Committee ----------------- (more information here: https://bobkonf.de/2020/programmkomitee.html) - Matthias Fischmann, Wire - Matthias Neubauer, SICK AG - Nicole Rauch, Softwareentwicklung und Entwicklungscoaching - Michael Sperber, Active Group - Stefan Wehr, factis research Scientific Advisory Board - Annette Bieniusa, TU Kaiserslautern - Torsten Grust, Uni Tübingen - Peter Thiemann, Uni Freiburg

1 0

postgresql-pure released
by 岡本和樹 24 Oct '19

24 Oct '19

Hello. I published a library “postgresql-pure”, which is a PostgreSQL driver written in pure Haskell, a few days ago. This library is developed to aim: - to increase the performance on multi CPU core environments - to run on multi platform - to build it easier especially on Windows to remove the dependency on libpq, which is made by C - there is postgres-wire which is a fast implementation but it doesn't support Windows I confirmed that: - the performance was proportional to the number of cores - the performance on 12 cores were 28% better than postgres-wire, 300% better than postgresql-simple Both test cases are simple constant value queries like “SELECT 2147483647 :: int4, …” to decrease server's load. I'm writing a report about this development and I will send email again. Please try this and feel free to report issues. Best, Kazuki Okamoto Hackage: http://hackage.haskell.org/package/postgresql-pure GitHub: https://github.com/iij-ii/postgresql-pure

1 0

[CC2020] Paper registration deadline *extended*. Last CFP for the ACM SIGPLAN 2020 International Conference on Compiler Construction
by Gabriel Rodríguez Álvarez 23 Oct '19

23 Oct '19

ACM SIGPLAN 2020 International Conference on Compiler Construction (CC'20) co-located with CGO, PPoPP and HPCA San Diego, CA, USA February 22 - 23, 2020 https://conf.researchr.org/home/CC-2020 The ACM SIGPLAN 2020 International Conference on Compiler Construction (CC 2020) is interested in work on processing programs in the most general sense: analyzing, transforming or executing input programs that describe how a system operates, including traditional compiler construction as a special case. Original contributions are solicited on the topics of interest which include, but are not limited to: - Compilation and interpretation techniques, including program representation, analysis, and transformation; code generation, optimization, and synthesis; the verification thereof - Run-time techniques, including memory management, virtual machines, and dynamic and just-in-time compilation - Programming tools, including refactoring editors, checkers, verifiers, compilers, debuggers, and profilers - Techniques for specific domains, such as secure, parallel, distributed, embedded or mobile environments - Design and implementation of novel language constructs, programming models, and domain-specific languages CC 2020 is the 29th edition of the conference. From this year onwards, CC is an ACM SIGPLAN conference and will implement guidelines and procedures recommended by SIGPLAN https://www.sigplan.org. ============================================================================================== To subscribe to the CC announce mailing list, see cc_conference_announce(a)googlegroups.com To subscribe to the CC announce Twitter account, see @cc2020conf (https://twitter.com/cc2020conf) ============================================================================================== IMPORTANT DATES Abstract Submission: 25 October 2019 ***** EXTENDED ***** Paper Submission : 30 October 2019 Rebuttal : 4-6 December 2019 Artifact Submission: 13 December 2019 Author Notification: 24 December 2019 Final papers due : 15 January 2020 Conference : 22–23 February 2020 All submissions must be made electronically through the conference web site and include an abstract (100–400 words), author contact information, the full list of authors and their affiliations. Full paper submissions must be in PDF formatted printable on both A4 and US letter size paper. All papers must be prepared in ACM Conference Format using the 2-column acmart format. Papers should contain a maximum of 10 pages of text (in a typeface no smaller than 10 point) or figures, NOT INCLUDING references. There is no page limit for references and they must include the name of all authors (not {et al.}). Appendices are not allowed, but the authors may submit supplementary material, such as proofs or source code; all supplementary material must be in PDF or ZIP format. Looking at supplementary material is at the discretion of the reviewers. Submission is double blind and authors will need to identify any potential conflicts of interest with PC, as defined here: http://www.sigplan.org/Resources/Policies/Review/ (ACM SIGPLAN policy). Authors are encouraged to submit their artifacts for the Artifact Evaluation (AE). The Artifact Evaluation process is run by a separate committee whose task is to assess how the artifacts support the work described in the papers. To ease the organization of the AE committee, we kindly ask authors to submit their artifact at the latest 10 days after the rebuttal. Papers that go through the Artifact Evaluation process successfully will receive a seal of approval printed on the papers themselves. Additional information will be made available on the CC AE web page. Deadlines expire at midnight anywhere on earth. ORGANIZERS General Chair Louis-Noel Pouchet Colorado State University <pouchet AT colostate.edu> Program Chair Alexandra Jimborean Uppsala University <alexandra.jimborean AT it.uu.se> Artifact Evaluation Chairs Michel Steuwer University of Glasgow <Michel.Steuwer AT glasgow.ac.uk> Martin Kong University of Oklahoma Publicity Chair Gabriel Rodriguez University of A Coruna Web Chair Mihail Popov Uppsala University Steering Committee Bjorn Franke University of Edinburgh <bfranke AT inf.ed.ac.uk> Sebastian Hack Saarland University Manuel Hermenegildo IMDEA SW Institute and Technical U. of Madrid Peng Wu Huawei America Research Lab Ayal Zaks Intel and Technion, Israel Jingling Xue University of New South Wales, Australia Christophe Dubach University of Edinburgh Nelson J. Amaral University of Alberta Milind Kulkarni Purdue University Program Committee Apan Qasem AMD/Texas State University Bernhard Scholz University of Sydney Bettina Heim Microsoft Bilha Mendelson Optitura Brian Demsky UC Irvine Changhee Jung Purdue University Christian Schulte KTH EJ Park Los Alamos National Laboratory Delphine Demange Inria Dongyoon Lee Stony Brook University Fernando Magno Quintao Pereira UFMG Brazil Haowei Wu Google Manuel Hermenegildo IMDEA and T.U. Madrid Matin Hashemi Sharif University of Technology Michel Steuwer University of Glasgow Mila Dalla Preda University of Verona Nelson J. Amaral University of Alberta Philippe Clauss University of Strasbourg Pavlos Petoumenos University of Edinburgh Rumyana Neykova Brunel London Santosh Nagarakatte Rutgers University Sebastian Hack University of Saarland Tomofumi Yuki Inria Xu Liu College of William and Mary

1 0

Bristol Haskell Hackathon 2020
by Matthew Pickering 21 Oct '19

21 Oct '19

I have decided to organise an informal hackathon in Bristol at the start of next year. When 25th-26th January 2020 Where Merchant Venturers Building - University of Bristol Time 09:00 - 17:00 Anyone interested in Haskell is welcome to attend. Whether you are a beginner or an expert it would be great to meet you in Bristol. It is a no-frills hackathon, we’ll provide a room for hacking and wifi but expect little else! There will be no t-shirts, food, talks or other perks. The focus will be 100% on hacking and meeting other Haskell programmers. For further information about the event and how to register please refer to the dedicated page. https://mpickering.github.io/bristol2020.html Cheers, Matt

1 0

Re: [Haskell-cafe] Explicit approach to lazy effects For probability monad?
by Olaf Klinke 20 Oct '19

20 Oct '19

> It kind of seems like this can't work if >>= has type 'm a -> (a -> m b) > -> mb', assuming m a = (a,state). The second argument needs to have > type (m a -> m b) instead of (a -> m b), since the computation needs to > have access to the state produced by the first "m a" computation, in > order to (optionally) depend on the state thread for first computation. My earlier suggestion of using the pure reader monad is not useful for two reasons: (1) A single random number is shared among all sub-computations, which destroys statistical independence. (2) Multi-dimensional distributions arguably require more than a single floating point number to parametrize. Maybe the following two monads hint at a better way, although none of them exhibits the two desirable properties I suggested in my first reply. It seems that both exhibit the sequential nature that you want to avoid, if the underlying monad m is sequential (i.e. stateful). (a) The free monad over the reader functor. type Distribution a = Free ((->) Double) a = Pure a | Impure (r -> Free ((->) Double) a) This is a reader monad of functions (Double,Double,...,Double) -> a where the tuple length may be any finite number. -- @choose p@ chooses the first distribution with probability @p@. choose :: Double -> Distribution a -> Distribution a -> Distribution a choose p x y = Impure (\r -> if r <= p then x else y) -- Feed a random number generator into a distribution. -- You get to decide which monad that is. sample :: Monad m => m r -> Free ((->) r) a -> m a sample _ (Pure a) = pure a sample gen (Impure f) = (sample gen) =<< (fmap f gen) (b) A reader monad which passes copies of the random number generator around, not the generator state. Again, you get to choose which monad the random number generator lives in. type DistrT m a = ReaderT (m Double) m a ~ m Double -> m a -- 'chooseT' queries the random number generator once -- and then passes it down to either of the two choices. chooseT :: Monad m => Double -> DistrT m a -> DistrT m a -> DistrT m a chooseT p x y = ReaderT (\gen -> gen >>= (\r -> if r <= p then runReaderT x gen else runReaderT y gen)) sampleT = runReaderT :: DistrT m a -> m Double -> m a Apologies that I can not be any more helpful at the moment. But the topic really interests me, please do post any progress on haskell-cafe. Olaf

1 0

problem with servant and type constrains
by PICCA Frederic-Emmanuel 17 Oct '19

17 Oct '19

Hello, I have a type for my APi like this type SubscribeAPI a = "upload" :> ReqBody '[JSON] (JobSpecSub a) :> Post '[JSON] () type HomepageAPI = "homepage" :> QueryParam "id" Int :> Get '[HTML] Homepage type XdsMeAPI a = "xdsme" :> ReqBody '[FormUrlEncoded] XdsMeRequest :> Post '[JSON] (JobSpecSub a) type LogsAPI = "logs" :> ReqBody '[FormUrlEncoded] LogsRequest :> Post '[HTML] Html type ResumXdsAPI = "resumxds" :> ReqBody '[FormUrlEncoded] ResumXdsRequest :> Post '[HTML] Html type SessionIdAPI = "sessionid" :> ReqBody '[FormUrlEncoded] SessionIdRequest :> Post '[HTML] Html type MyApi a = SubscribeAPI a :<|> HomepageAPI :<|> XdsMeAPI a :<|> LogsAPI :<|> ResumXdsAPI :<|> SessionIdAPI myApi :: Job a => Proxy (MyApi a) myApi = Proxy When I try to write the handler for this API, I have this error message for the next code myAPIServer :: Job a => Beamline -> JobQueue a -> Server (MyApi a) myAPIServer beam jobQueue = handleJobSpec :<|> handleHomepage :<|> handleXdsMe :<|> handleLogs :<|> handleResumXds :<|> handleSessionId where handleJobSpec :: Job b => JobSpecSub b -> Handler () handleJobSpec jobSpec = liftIO $ enqueue jobSpec jobQueue • Couldn't match type ‘a’ with ‘b’ ‘a’ is a rigid type variable bound by the type signature for: myAPIServer :: forall a. Job a => Beamline -> JobQueue a -> Server (MyApi a) at src/Web.hs:235:1-66 ‘b’ is a rigid type variable bound by the type signature for: handleJobSpec :: forall b. Job b => JobSpecSub b -> Handler () at src/Web.hs:238:5-56 Expected type: JobQueue b Actual type: JobQueue a • In the second argument of ‘enqueue’, namely ‘jobQueue’ In the second argument of ‘($)’, namely ‘enqueue jobSpec jobQueue’ In the expression: liftIO $ enqueue jobSpec jobQueue • Relevant bindings include jobSpec :: JobSpecSub b (bound at src/Web.hs:239:19) handleJobSpec :: JobSpecSub b -> Handler () (bound at src/Web.hs:239:5) jobQueue :: JobQueue a (bound at src/Web.hs:236:18) myAPIServer :: Beamline -> JobQueue a -> Server (MyApi a) (bound at src/Web.hs:236:1) | 239 | handleJobSpec jobSpec = liftIO $ enqueue jobSpec jobQueue | ^^^^^^^^ I understand that I need to explain haskell that a ~ b. So my question is how can I do this :) thanks for your help Frederic

2 1

Re: [Haskell-cafe] stack: pandoc fails to build as dependency
by Olaf Klinke 17 Oct '19

17 Oct '19

>> [...] Can you get more info about what the linker error is? > Indeed, the linker exiting with status 1 without any stderr > message sounds like your linker is crashing. > take the last `ghc` invocation it makes, run that directly and add `-v` to that to get GHC's verbose output, which will show you the full linker invocation I don't know yet what causes the linker to crash, but I found a work-around: If I download any pandoc version, extract it and run `stack build` inside that directory, it is fine. So I created a symlink to that local pandoc dir inside my package root and made pandoc a part of my own package. Then everything builds all right. Hence there must be something going wrong when stack downloads and builds pandoc somewhere inside .stack-work/. It seems difficult to just run the last sub-command as Niklas suggests, because after the crash all the temporary files of the failed build are gone. But I'll keep investigating, thanks for the suggestions! Olaf

2 1

Windows, doctest and auxiliary FFI wrappers?
by Viktor Dukhovni 16 Oct '19

16 Oct '19

The Network.DNS library contains a bit of helper C-code for determining the default DNS servers on Windows. This code is linked in by Cabal, when building object code for the library on Windows. The library also has 140 "doctest" examples in the haddock comments, which I'd like to test on Windows via AppVeyor. I'm not having much luck making the dependency on the cbits visible to the GHCi invocations executed by "Test.Doctest". Does anyone have some experience getting this sort of thing to work? What I've tried: 1. Add "-liphlpapi" into the "doctest" command argument list, this proved necessary, but not sufficient. 2. Build a separate internal library (supported in Cabal 2.0 and later), which is a dependency of the main library and links in the C glue code, but this proved to be a significant rabbit hole... In fact approach 2 seems like the more promising one, but it runs into a substantial obstacles: a. Building internal libraries requires a "Simple" Cabal build, but the cabal-doctest package which automates compiling doctests, requires a "Custom" build type. :-( b. A Simple build, means abandoning cabal-doctest, and using "doctest" directly, but the new sandbox builds place package artefacts in locations that the command-line invoked by "Test.DocTest.doctest" does not know how to find. It appears that the "Custom" build from cabal-doctest is there for a good reason: it hooks into Cabal's build process, and has access to enough metatata, to generate wrapper code that invokes doctest with an argument list of the form: -XCPP -i -i<DISTDIR>/build/<ARCHDIR>/<GHCVER>/<PKG>-<VER>/build/autogen -i<DISTDIR>/build/<ARCHDIR>/<GHCVER>/<PKG>-<VER>/build -i<SRCDIR> -package-env=- -hide-all-packages -no-user-package-db -package-db=<CABALGLOBALSTORE>/<GHCVER>/package.db -package-db=<DISTDIR>/packagedb/<GHCVER> -package-db=<DISTDIR>/build/<ARCHDIR>/<GHCVER>/<PKG>-<VER>/package.conf.inplace -optP-include -optP<DISTDIR>/build/<ARCHDIR>/<GHCVER>/<PKG>-<VER>/build/autogen/cabal_macros.h ...visible packages... ...modules to doctest... which are needed for the extracted doctest fragments to find their dependencies. Hard-coding such arguments into the "Simple" build seems to work, but is hardly maintainable. I've not yet found an interface in the Cabal library that would divulge these magic strings as a function of the "pkg.cabal" file, something of the shape: cabalMagicGhcArgs :: FilePath -> IO [String] would make it possible to compute the arguments at runtime (rather than build-time) in a Simple build, without having to use a Custom build to machine-generate wrapper code. Other than the above, I'm out of ideas for now, any help much appreciated. -- Viktor.

1 1

Using GHCJS on firebase functions
by Ruben Astudillo 16 Oct '19

16 Oct '19

Dear list Has anyone used GHCJS on Firebase functions? How has it been your experience? Would you recommend it or offer al alternative?. -- -- Ruben -- PGP: 4EE9 28F7 932E F4AD

1 0

Avoiding code-duplication for what is roughly fmap
by Sebastiaan Joosten 15 Oct '19

15 Oct '19

Hi all, I'm writing a lot of code that looks like this: instance WhiteSpaced ClassItem where removeWS (Method a b c) = Method (removeWS a) (removeWS b) (removeWS c) removeWS (Declaration b) = Declaration (removeWS b) Typically, all the way at the end there's an instance that deviates (sometimes the deviating instances are somewhere in the middle). I need to do this for a lot of functions, and a lot of data types, and all I'm doing here is rewriting the data-type declaration in a different syntax (except that you do not know the types of a, b and c from the above). For the sake of maintainability, I want to avoid this code-duplication and focus only on the deviating instances. How to do better? I don't see how to use generics (in the hope of only writing 'instance WhiteSpaced ClassItem where' instead of the three lines above) for this: the types for a, b and c are all different here. Would this be easier with Template Haskell? (in the hope of only writing $(''something ClassItem) instead of the three lines above) My main concern is maintainability, an ideal solution is either a clear one-liner or a library import (in the same way that aeson allows me to use generics or Template Haskell without needing to know much about them). Other solutions are welcome too. Best, Sebastiaan

4 5

Re: [Haskell-cafe] Is join useful for every monad?
by Ruben Astudillo 14 Oct '19

14 Oct '19

On 14-10-19 16:45, Carter Schonwald wrote: > And while join is not at the moment in the Monad typeclass because of > newtype stuff Could you expand a bit on this? I remember this being on a Applicative-Monad proposal but I couldn't understand why it wasn't technically possible. -- -- Ruben -- PGP: 4EE9 28F7 932E F4AD

2 1

[Job] Muse Dev, a Galois spin-out, is hiring
by Thomas DuBuisson 14 Oct '19

14 Oct '19

Muse Dev is a Galois spin-out working to put the rest of Galois out of business by automating their jobs away [1]. By discovering "the right issues at the right time" and presenting to the developer, Muse seeks to bring static code analysis to the world as early in the development cycle as possible. We're currently working with early adopters to flesh-out the interface and add final must-haves. Oh, and we are hiring. If you like all-Haskell backends, have SaaS-related experience, and love build systems then please apply. We're interested in people with experience and enthusiasm in some of: * Haskell development * Static analysis * Build system interpretation * Kubernetes cluster deployment * AWS such as EC2, IAM, EKS * REST APIs * Enterprise system deployment, packaging, and support Location: Galois offices in Portland, Oregon or Arlington, Virginia. Resumes can be sent to careers(a)muse.dev See Also https://muse.dev <https://muse.dev/careers> https://lifeatgalois.com - We have inherited some culture from Galois but are a separate company. [1] Well, anything that can be automated about program analysis. Don't tell Galois. They'll kick us out of this nice, comfy, office.

1 0

Optional "Default" instances of classes in certain subcases (but too broad)
by Juan Casanova 14 Oct '19

14 Oct '19

Hello again, Before my question, I notice I am using this list quite a bit. I hope I am no abusing or misusing it by doing so, though. Sometimes I wonder what's the line between what I should ask here and what I should ask in StackOverflow, if that line even exists. If anyone feels I may be abusing or misusing, please let me know (in public or in private). Very simple question: Would it make sense, or does it already exist, a way to implement *optional* default instances of classes that can be used more directly than currently. I am *not* talking about providing a default implementation of a class when declaring it. I know you can do this. I am talking about when you know you can provide a generic instance of a class for a wide range of situations *which depends on some constraints*. For example: instance Bifunctor f => Functor (f a) where fmap = bimap id Of course, this is a terrible idea, because the constraints are not checked when verifying overlap and the like, and so this is very likely to break your program. What I tend to do nowadays is to add a function: fmapFromBiMap :: Bifunctor f => (b -> c) -> (f a b) -> (f a c) fmapFromBiMap = bimap id and then use it each time (the following is obviously a silly example): instance Functor (Either a) where fmap = fmapFromBiMap The only problem I see with this is that I need to remember (specially with my own type classes): 1. That I provided this "default" implementation. 2. Its name. I know these are fairly small things to complain about, but once again when you do it 100 times it becomes annoying, specially for a person who absolutely does not like doing things that I know would be able to explain how to automate. So, what I would expect is for it to be something like declaring the default instance but only use it for the types that explicitly ask for it. E.g.: optional instance Bifunctor f => Functor (f a) where fmap = bimap id instance Functor (Either a) using optional The main important point here is that I expect this to check the constraints in compile time for the class that I am giving (and if it contains type variables, only use those that are guaranteed to be complied, of course). This means that if I did: instance Functor (f a) using optional I *do not* expect it to be okay with it and automatically add the constraint Bifunctor f => to the instance. I expect it to give me a compile error: "No matching optional instance found". Of course, there could be several optional instances that overlap when using optional. But then, GHC would give me the error indicating what the options are *and I would know that it's because I put optional* and I could just replace it with the specific one to use. Maybe by giving them names? optional instance fmapFromBiMap Bifunctor f => Functor (f a) where fmap = bimap id instance Functor (Either a) using optional -- If this does not work because it overlaps with other optionals, then GHC tells me, indicates the options, and I replace with: instance Functor (Either a) using fmapFromBiMap This avoids the problem of defining the instance in general (that it will overlap with basically anything), should be easy to type check and prevents having to keep an index in your mind about useful functions that you implemented or didn't. I wonder if the "deriving" family of functionalities have anything like this, but my search has not been fruitful. Maybe using Generics? Maybe I just need good autocomplete so that I can find the function easily... it still feels like this would make sense. Juan. -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

2 4

Feedback First Application
by Casper Thule Hansen 14 Oct '19

14 Oct '19

Hi. I have created my first application that I expect will go live within the next couple of months and I would like to have some feedback. The application is here: https://github.com/into-cps-association/utilities_backend and will be a project that I keep updating as I learn new stuff. I consider myself somewhat a haskell beginner, and my goal is to learn more about Haskell's features, packages and similar. So I hope that someone can point me to some places in my code that can be written in a better fashion, concepts that can be applied or similar. Of course - please try to keep it within my reach 🙂 The application is not critical in any fashion. It is not necessary with optimal performance, extensive testing and similar. Currently, I am not particularly interested in testing, I will save that for later. I hope someone can give me a few pointers! Cheers, Casper Thule

1 0