- Haskell-Cafe - Haskell.org

Dashboard
by Anton Pichugin 08 Jun '22

08 Jun '22

Hello everyone in the Haskell cafe! Such a nice place! My name is Anton. A month ago I started learning Haskell. I want to make a dashboard about the language. What data should I analyze and add to it? I see this project as a page where you can see charts and diagrams that change in real time. As of now I only have Google Trends (search Interest over time) + number of commits on GitHub. What else can I visualize? Which one could be helpful to the community? Kind regards, Anton Pichugin

3 2

[ANN] Yampa 0.13.5
by Ivan Perez 08 Jun '22

08 Jun '22

Dear all, I'm happy to announce the release of Yampa 0.13.5! Yampa is a fast, elegant FRP library that enforces a separation between effects (e.g., user input, rendering) and FRP signal function specifications.Yampa prides itself in being a long-standing community project. It's now been around for almost 20 years!!! In all this time, it has enjoyed abundant use in research, in open source, and in industry. * Summary of changes - Tests in the yampa-test library have now been reorganized to follow the same structure of Yampa. This change will make it easier to identify what tests are missing. A summary has been produced as part of an issue [1]. - A less-known feature of Yampa is that applicative style is also supported, and renders programs reminiscent of classic FRP. To make Yampa more inviting to users who prefer such style, the descriptions in the package, README and main module have been adapted so that they do not suggest that arrows syntax or the arrow-based interface is the only available or even preferred style. - Tabs will now produce a compilation error. - Multiple maintenance fixes (fix broken links in documentation, remove unnecessary imports, style fixes, etc.). As always, Yampa and yampa-test are released in sync. The CHANGELOGs are available at: https://github.com/ivanperez-keera/Yampa/blob/develop/yampa/CHANGELOG https://github.com/ivanperez-keera/Yampa/blob/develop/yampa-test/CHANGELOG * Releases You can explore the current versions at: https://hackage.haskell.org/package/Yampa https://hackage.haskell.org/package/yampa-test * Code The github repo is located at: https://github.com/ivanperez-keera/Yampa * Upcoming changes We are discussing an upcoming change that may affect users. We are interested in knowing if/how this would affect you (if at all). - Addition of new constraint to integral/derivative: The VectorSpace implementation we are using imposes the Eq and Floating constraints on vector spaces, but they have turned out not to be necessary. An alternative implementation is being proposed [2], which removes those constraints, and gives default implementations for some functions that meet some type constraints. This change would require adapting the code of integral, derivative and some related functions to impose an additional type constraint. We expect most user code to be compatible, but the change is, technically, API-breaking. This topic is open to discussion, we invite interested users to come forward. * Other notes: We have a plan for the upcoming releases. Check out the project issues or message me if you are interested in participating. https://github.com/ivanperez-keera/Yampa/issues All the best, Ivan [1] https://github.com/ivanperez-keera/Yampa/issues/217 [2] https://github.com/ivanperez-keera/simple-affine-space/tree/develop-no-cons…

1 0

Deadline Extended: 26th Brazilian Symposium on Programming Languages (SBLP 2022)
by Cristiano D. Vasconcellos 07 Jun '22

07 Jun '22

SBLP 2022 is the 26th edition of the Brazilian Symposium on Programming Languages<https://cbsoft2022.facom.ufu.br/sblp.php>. It is promoted by the Brazilian Computer Society (SBC) and constitutes a forum for researchers, students, and professionals to present and discuss ideas and innovations in the design, definition, analysis, implementation, and practical use of programming languages. SBLP's first edition was in 1996. Since 2010, it has been part of CBSoft, the Brazilian Conference on Software: Theory and Practice. The Conference is planned to be held on October 3-7, 2022, fully online. Submission Guidelines Papers can be written in Portuguese or English. Submissions in English are encouraged considering that only accepted papers written in English will appear in the proceedings, usually indexed in the ACM Digital Library (to be confirmed). The acceptance of a paper implies the registration of at least one author in the symposium to present it. Papers must be original and not simultaneously submitted to another journal or conference. No-show of scheduled papers will result in excluding them from the proceedings. SBLP 2022 will use a lightweight double-blind review process. The manuscripts should be submitted for review anonymously (i.e., without listing the author’s names on the paper) and references to own work should be made in the third person. Papers must be submitted electronically (in PDF format) via the EasyChair System.<https://easychair.org/conferences/?conf=sblp2022> The following paper categories are welcome (page limits include figures, references, and appendices): • Full papers: up to 8 pages long in ACM 2-column conference format.<http://www.acm.org/publications/proceedings-template> Full papers can be further specialized, at submission time, as student papers (i.e., as papers describing research conducted mainly by a student at any level). student papers will be subject to the exact same reviewing process and criteria but may be entitled for an award (see below). • Short papers: up to 3 pages in the same format. Short papers can discuss new ideas which are at an early stage of development or can report partial results of on-going dissertations or theses. Each paper can have a maximum of one extra page for references. Active graduate and undergraduate students seeking feedback are invited to submit short papers of their original unpublished and in-progress research work. A set of selected papers, which did not get accepted as full papers, may be accepted as short papers. Awards: Two best paper awards will be attributed, distinguishing full paper submissions of the best: • student paper; • non-student paper. List of Topics (related but not limited to the following): • Programming paradigms and styles, scripting and domain-specific languages and support for real-time, service-oriented, multi-threaded, parallel, distributed, and quantum programming; • Program generation and transformation; • Formal semantics and theoretical foundations: denotational, operational, algebraic, and categorical; • Program analysis and verification, type systems, static analysis, and abstract interpretation; • Programming language design and implementation, programming, language environments, compilation, and interpretation techniques; • Programming languages for the blockchain technology: design and implementation of Smart Contract languages, implementation of consensus protocols, language-based security, and cryptographic primitives. A selection of the best papers appearing in the last editions of SBLP have been invited to be extended and considered for publication in a special issue of the Journal of Computer Languages (COLA), by Elsevier. We will approach COLA for a similar special issue regarding the 2022 edition of SBLP. Important dates: • Abstract submission: 20 June, 2022. • Paper submission: 20 June, 2022. • Author notification: 16 Aug, 2022. • Camera ready deadline: 29 Aug, 2022. Program Committee Program Committee Chair: Cristiano Vasconcellos, UDESC Program Committee Alberto Pardo, Universidad de la República Alcides Fonseca, Universidade de Lisboa Alejandro Díaz-Caro, Universidad Nacional de Quilmes & Universidad de Buenos Aires Alex Kavvos, University of Bristol Anderson Faustino, UEM Andrei Paskevich, Université Paris-Sud, LRI Andre Maidl, Elastic Dalvan Griebler, PUCRS/SETREM Emmanuel Chailloux, University Pierre and Marie Curie Fernando Castor, UFPE & Utrecht University Fernando Pereira, UFMG Francisco Sant'anna, UERJ Karina Roggia, UDESC Leonardo dos Santos, UFJF Liam O'Connor, University of Edinburgh Marcos Viera, Universidad de la República Mário Pereira, Universidade NOVA de Lisboa Mariza Bigonha, UFMG Nuno Macedo, INESC TEC & University of Porto Paul Leger, Universidad Católica del Norte Roberto Bigonha, UFMG Roberto Ierusalimschy PUC-Rio Rodrigo Ribeiro, UFOP Samuel Feitosa, UFFS Sérgio Medeiros, UFRN Simão Sousa, Universidade da Beira Interior Stefania Dumbrava, ENSIIE Paris-Evry Contact: All questions about submissions should be emailed to cristiano.vasconcellos(a)udesc.br

1 0

Re: [Haskell-cafe] Should there be a haskell template for inclusion polymorphism in Haskell?
by Olaf Klinke 05 Jun '22

05 Jun '22

> So my central questions for discussions are: > > - Is inclusion polymorphism something we should use at all in Haskell? > - These boiler plate code maybe better be generated using Haskell template > instead, is there one already, or should > there be one? Maybe one of the authors of a sub-typing library can share a more informed opinion on this. My view as a mathematician: A type being a subtype of another is a relation between types. Relations between types is what multi-parameter type classes is about. Hence it seems that this is how subtypes in Haskell ought to be done. For example, in the attenuation and records-sop package, the latter of which is based on genercis-sop, which depends on Template Haskell. So without having used any of the mentioned packages, I believe your second question can be answered with "yes". Regarding the first question, we should probably ask ourselves how much type-safety we're sacrificing for the convenience we gain. The Num example you gave shows one possible danger: While a subtype relation may hold mathematically, the implementiation details may cause this relation to fail in reality. Example: All floating point numbers are rationals, aren't they? So there should be a subtype relation. But how to convert NaN, -infinity or -0 of type Double to a pair of Integers? Olaf

3 6

cabal 3.8 pre-released!
by Mikolaj Konarski 05 Jun '22

05 Jun '22

Hello! The first 3.8 series cabal release candidate is available. Install via ghcup config add-release-channel \ https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-prere…; ghcup install cabal 3.8.0.20220526 or manually from https://downloads.haskell.org/cabal/cabal-install-3.8.1.0-rc1/. We, the cabal team, are completely dependent on our invaluable contributors and collaborators, thanks to whom this pre-release is possible. Therefore, please test extensively and if anything critical is missing or broken that you'd like to see fixed in 3.8.1.0-final, let us know on the bug tracker. There is still a narrow window to change things and the cabal team will try to guide you along and help you implement them. The dynamic list of known grave bugs that could plausibly be solved for 3.8 is at https://github.com/haskell/cabal/issues?q=is%3Aopen+is%3Aissue+label%3A%22p… At the time of writing none of the bugs on the list is blocking the final 3.8 release. Changelogs are at https://github.com/haskell/cabal/blob/Cabal-v3.8.1.0-rc1/release-notes/Caba… https://github.com/haskell/cabal/blob/cabal-install-v3.8.1.0-rc1/release-no… The list of all authors of cabal is the git commit log. You are great. Happy hacking, Mikolaj

3 5

ANN: hledger-1.26
by Simon Michael 05 Jun '22

05 Jun '22

Aloha! I am pleased to announce hledger 1.26: https://github.com/simonmichael/hledger/releases/1.26 https://hledger.org/install https://hledger.org/release-notes.html#hledger-1-26 1.26 is a modest maintenance release; highlights include faster register reports and clearer error messages. Thank you to core contributor Stephen Morgan. What is hledger ? - free, high quality Plain Text Accounting[1] software: - a fast and robust multicurrency double-entry accounting system - built around human-readable, version-controllable plain text files - inspired by and partly compatible with Ledger CLI[2] - convertible to and from Beancount[3] - written in Haskell for correctness and longevity - easy to install on unix, mac and windows. For help getting started, or more info, see https://hledger.org, and join our chat via Matrix or IRC: https://hledger.org/support. Newcomers, experts, contributors, sponsors, feedback are always welcome! Best wishes, -Simon [1] https://plaintextaccounting.org [2] https://ledger-cli.org [3] https://beancount.github.io

1 1

Re: [Haskell-cafe] Hiding type variables from the signature?
by Olaf Klinke 03 Jun '22

03 Jun '22

> λ f = deasilsB . deasilsA > > <interactive>:2:1: error: > • Could not deduce: Dress seed0 peels0 ~ Dress seed peels > ``` > > What is going on? How can I have my `deasils`? > > I tried attaching all kinds of type annotations, but nothing works so far. I do > not even understand the problem. How is it that an expression can be typed, but > cannot be assigned to a name? > > You can see the complete code at the gist [1]. > > [1]: https://gist.github.com/kindaro/6056f753bcf356ced96b817fee72533c/2823ec2792… The given type annotation for desilsA uses forall, which suggests you want to use ScopedTypeVariables here. But for that feature to kick in, you need to actually mention the scoped type variables in the function body, which you don't. :t deasil . first squeeze deasil . first squeeze :: (ForAll peels Functor, Squeezy' left a peels (Strip left a == '[])) => (a, right) -> Squeezed peels (left, right) You must use ScopedTypeVariables to constrain the type variable `a' to the intended (Dress seed peels). Olaf

1 0

Hiding type variables from the signature?
by Ignat Insarov 02 Jun '22

02 Jun '22

Hello café, hope you all doing well! I have this code [1]. Its purpose is to provide an `fmap` that works at any depth. Here is the gist of the gist: ```Haskell fmapz ∷ forall seed fruit seed' fruit' peels recursive. Squeezish seed seed' fruit fruit' peels recursive ⇒ (seed → seed') → fruit → fruit' fmapz function = stretch . fmap @(Squeezed (Strip seed fruit)) function . squeeze ``` As the examples show, it works, and even has some type inference. However, the type signature is unwieldy. It seems like it should have only 4 variables, but I have to also do some type level book-keeping for which the other 2 variables are needed. These book-keeping type variables are determined by type families from the other 4, so surely I can hide them inside a type synonym or something like that? I tried giving a quantified constraint, like so: ```Haskell type Squeezish ∷ ★ → ★ → ★ → ★ → Constraint type Squeezish seed seed' fruit fruit' = forall peels recursive. Squeezish' seed seed' fruit fruit' peels recursive class Squeezish' seed seed' fruit fruit' (peels ∷ [★ → ★]) (recursive ∷ Bool) instance ( peels ~ Strip seed fruit , ForAll peels Functor , Squeezy seed' fruit' peels recursive , Squeezy seed fruit peels recursive ) ⇒ Squeezish' seed seed' fruit fruit' peels recursive ``` — But then the constraints from the context of `Squeezish'` fail to make it to the use site and numerous errors arise. What can I do to solve this problem? Or is it theoretically impossible? [1]: https://gist.github.com/kindaro/6056f753bcf356ced96b817fee72533c

1 2

403 trying to upload hackage package candidate
by ☂Josh Chia (謝任中) 01 Jun '22

01 Jun '22

Hi, After running 'cabal sdist', I tried to upload a package candidate for direct-sqlite and got an inexplicable error. Any idea how I should proceed? You can see that I am one of the maintainers here: https://hackage.haskell.org/package/direct-sqlite/maintainers/ $ cabal upload -u jchia -P 'cat /tmp/pw' /home/jchia/gh/direct-sqlite/dist-newstyle/sdist/direct-sqlite-2.3.27.tar.gz Uploading /home/jchia/gh/direct-sqlite/dist-newstyle/sdist/direct-sqlite-2.3.27.tar.gz... Error uploading /home/jchia/gh/direct-sqlite/dist-newstyle/sdist/direct-sqlite-2.3.27.tar.gz: http code 403 Error: Forbidden No access for this resource.

2 2

Keith Hanna
by chris done 01 Jun '22

01 Jun '22

Hi all, Does anyone know whether Keith Hanna is still active in the Haskell community? He's apparently no longer at the University of Kent (I called and asked) and has no discernible web presence besides research papers that refer to his Kent email address. He was mentioned in the community activities report in 2004 for his work on Vital, which I'd like to get in touch with him about. Cheers, Chris

1 0

ML Family Workshop 2022: DEADLINE EXTENSION
by Benoit Montagu 31 May '22

31 May '22

To increase your chances of submitting your work to the ML workshop, *the submission deadline is extended by a week*. The new deadline is Friday 10th June (AoE). A quick reminder: - The workshop does not have proceedings, making it the perfect venue to run some ideas with the community or present some work in progress within a friendly environment. - The work load as an author is low: submissions are only 3 pages long (excluding references) - YOU have the power to make the ML workshop a success! - You have one more full week to submit to <https://ml2022.hotcrp.com/> (please register your submission early!) - All the details are here: <https://icfp22.sigplan.org/home/mlfamilyworkshop-2022#Call-for-Presentations> - The ML workshop is colocated with ICFP 2022 <https://icfp22.sigplan.org/> -- Benoît Montagu, chair of the ML workshop 2022

1 0

Haskell Symposium 2022: Abstract Deadline Extended to June 1st
by Nadia Polikarpova 29 May '22

29 May '22

The Haskell'22 abstract deadline has been extended to *Wednesday, June 1st*. Please register your submissions by this date! The full submission deadline is still *Friday, June 3rd*. Please find the updated CFP below. Nadia Polikarpova (Haskell'22 chair) ========================================================================= ACM SIGPLAN CALL FOR SUBMISSIONS Haskell Symposium 2022 Ljubljana, Slovenia Thu 15 -- Fri 16 September, 2022 http://www.haskell.org/haskell-symposium/2022/ ========================================================================= The ACM SIGPLAN Haskell Symposium 2022 will be co-located with the 2022 International Conference on Functional Programming (ICFP). Differently from previous years, Haskell'22 will use a single-track submission process (that is, we will only have the regular track and no early track). The Haskell Symposium presents original research on Haskell, discusses practical experience and future development of the language, and promotes other forms of declarative programming. Topics of interest include: * Language design, with a focus on possible extensions and modifications of Haskell as well as critical discussions of the status quo; * Theory, such as formal semantics of the present language or future extensions, type systems, effects, metatheory, and foundations for program analysis and transformation; * Implementations, including program analysis and transformation, static and dynamic compilation for sequential, parallel, and distributed architectures, memory management, as well as foreign function and component interfaces; * Libraries, that demonstrate new ideas or techniques for functional programming in Haskell; * Tools, such as profilers, tracers, debuggers, preprocessors, and testing tools; * Applications, to scientific and symbolic computing, databases, multimedia, telecommunication, the web, and so forth; * Functional Pearls, being elegant and instructive programming examples; * Experience Reports, to document general practice and experience in education, industry, or other contexts; * Tutorials, to document how to use a particular language feature, programming technique, tool or library within the Haskell ecosystem; * System Demonstrations, based on running software rather than novel research results. Regular papers should explain their research contributions in both general and technical terms, identifying what has been accomplished, explaining why it is significant, and relating it to previous work, and to other languages where appropriate. Experience reports and functional pearls need not necessarily report original academic research results. For example, they may instead report reusable programming idioms, elegant ways to approach a problem, or practical experience that will be useful to other users, implementers, or researchers. The key criterion for such a paper is that it makes a contribution from which other Haskellers can benefit. It is not enough simply to describe a standard solution to a standard programming problem, or report on experience where you used Haskell in the standard way and achieved the result you were expecting. Like an experience report and a functional pearl, tutorials should make a contribution from which other Haskellers can benefit. What distinguishes a tutorial is that its focus is on explaining an aspect of the Haskell language and/or ecosystem in a way that is generally useful to a Haskell audience. Tutorials for many such topics can be found online; the distinction here is that by writing it up for formal review it will be vetted by experts and formally published. System demonstrations should summarize the system capabilities that would be demonstrated. The proposals will be judged on whether the ensuing session is likely to be important and interesting to the Haskell community at large, whether on grounds academic or industrial, theoretical or practical, technical, social or artistic. Please contact the program chair with any questions about the relevance of a proposal. If your contribution is not a research paper, please mark the title of your experience report, functional pearl, tutorial or system demonstration as such, by supplying a subtitle (Experience Report, Functional Pearl, Tutorial Paper, System Demonstration). Submission Details ================== Formatting ---------- Submitted papers should be in portable document format (PDF), formatted using the ACM SIGPLAN style guidelines. Authors should use the `acmart` format, with the `sigplan` sub-format for ACM proceedings. For details, see: http://www.sigplan.org/Resources/Author/#acmart-format It is recommended to use the `review` option when submitting a paper; this option enables line numbers for easy reference in reviews. Functional pearls, experience reports, tutorials and demo proposals should be labelled clearly as such. Lightweight Double-blind Reviewing ---------------------------------- Haskell Symposium 2022 will use a lightweight 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 an initial judgment 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. A reviewer will learn the identity of the author(s) of a paper after a review is submitted. Page Limits ----------- The length of submissions should not exceed the following limits: Regular paper: 12 pages Functional pearl: 12 pages Tutorial: 12 pages Experience report: 6 pages Demo proposal: 2 pages There is no requirement that all pages are used. For example, a functional pearl may be much shorter than 12 pages. In all cases, the list of references is not counted against these page limits. Deadlines --------- Abstract submission: 1 June 2022 (Wed) Paper submission: 3 June 2022 (Fri) Notification: 1 July 2022 (Fri) Deadlines are anywhere on Earth. Submission ---------- Submissions must adhere to SIGPLAN's republication policy (http://sigplan.org/Resources/Policies/Republication/) and authors should be aware of ACM's policies on plagiarism (https://www.acm.org/publications/policies/plagiarism) Program Committee members are allowed to submit papers, but their papers will be held to a higher standard. The paper submission deadline and length limitations are firm. There will be no extensions, and papers violating the length limitations will be summarily rejected. Papers should be submitted through HotCRP at: https://haskell22.hotcrp.com/ Improved versions of a paper may be submitted at any point before the submission deadline using the same web interface. Supplementary material: Authors have the option to attach supplementary material to a submission, on the understanding that reviewers may choose not to look at it. This supplementary material should not be submitted as part of the main document; instead, it should be uploaded as a separate PDF document or tarball. Supplementary material should be uploaded at submission time, not by providing a URL in the paper that points to an external repository. Authors can distinguish between anonymized and non-anonymized supplementary material. Anonymized supplementary material will be visible to reviewers immediately; non-anonymized supplementary material will be revealed to reviewers only after they have submitted their review of the paper and learned the identity of the author(s). Resubmitted Papers: authors who submit a revised version of a paper that has previously been rejected by another conference have the option to attach an annotated copy of the reviews of their previous submission(s), explaining how they have addressed these previous reviews in the present submission. If a reviewer identifies him/herself as a reviewer of this previous submission and wishes to see how his/her comments have been addressed, the conference chair will communicate to this reviewer the annotated copy of his/her previous review. Otherwise, no reviewer will read the annotated copies of the previous reviews. Proceedings =========== Accepted papers will be included in the ACM Digital Library. Their authors will be required to choose one of the following options: - Author retains copyright of the work and grants ACM a non-exclusive permission-to-publish license (and, optionally, licenses the work with a Creative Commons license); - Author retains copyright of the work and grants ACM an exclusive permission-to-publish license; - Author transfers copyright of the work to ACM. For more information, please see ACM Copyright Policy (http://www.acm.org/publications/policies/copyright-policy) and ACM Author Rights (http://authors.acm.org/main.html) Accepted proposals for system demonstrations will be posted on the symposium website but not formally published in the proceedings. Publication date: The official publication date of accepted papers is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of the conference. The official publication date affects the deadline for any patent filings related to published work. Artifacts ========= Authors of accepted papers are encouraged to make auxiliary material (artifacts like source code, test data, etc.) available with their paper. They can opt to have these artifacts published alongside their paper in the ACM Digital Library (copyright of artifacts remains with the authors). If an accepted paper's artifacts are made permanently available for retrieval in a publicly accessible archival repository like the ACM Digital Library, that paper qualifies for an Artifacts Available badge (https://www.acm.org/publications/policies/artifact-review-badging#available) Applications for such a badge can be made after paper acceptance and will be reviewed by the PC chair. Program Committee ================= Lennart Augustsson Epic Games Jean-Philippe Bernardy University of Gothenburg Iavor Diatchki Galois, Inc Michael Gale Tweag William Hallahan Yale University Makoto Hamana Gumma University Andrew Hirsch MPI SWS John Hughes Chalmers University of Technology Alexis King Tweag James Koppel Massachusets Institute of Technology Rudy Matela Channable Dominic Orchard University of Kent Nadia Polikarpova (chair) University of California, San Diego Eric Seidel Bridgewater Associates Satnam Singh Groq Wouter Swierstra Utrecht University Hiroshi Unno University of Tsukuba Marco Vassena Utrecht University Dimitrios Vytiniotis DeepMind If you have questions, please contact the chair at: npolikarpova(a)ucsd.edu =========================================================================

1 0

Research fellow position at University of Bristol
by Meng Wang 28 May '22

28 May '22

Dear Haskellers, The programming languages group at Bristol is recruiting a research fellow to join our dynamic research group https://bristolpl.github.io/. Our research is ranked highly internationally and there is a strong focus on Haskell. We welcome functional programmers anywhere in the world to apply! (Another similar post at the level of research associate is also available.) https://www.bristol.ac.uk/jobs/find/details/?jobId=274355&jobTitle=Research… Meng Wang, PhD (Oxon) Senior Lecturer of Programming Languages Head of PL research group School International Director SCEEM (CS, EEE, EMath) School, University of Bristol PS. A selection of recent papers can be found below. They should give a good indication of the type of PL research conducted at Bristol: - Perera et al. (2022). Linked visualisations via Galois dependencies. POPL 2022. 10.1145/3498668 - Xie et al. (2022). Staging with Class. POPL 2022. 10.1145/3498723 - Yamaguchi et al. (2021). Synbit: Synthesizing Bidirectional Programs using Unidirectional Sketches. OOPSLA 2021. 10.1145/3485482 - Qian Z et al. (2021). Client-Server Sessions in Linear Logic. ICFP 2021. 10.1145/3473567 - Jones E & Ramsay S. (2021). Intensional Refinement Datatypes. POPL 2021. 10.1145/3445980 - Gratzer D et al. (2020). Multimodal Dependent Type Theory. LICS 2020. 10.1145/3373718.3394736 - Matsuda K & Wang M. (2020). Sparcl: A Language for Partially-Invertible Computation. ICFP 2020. 10.1145/3409000 - Zhang J et al. (2019). A Study of Bug Resolution Characteristics in Popular Programming Languages. IEEE Transactions on Software Engineering. 10.1109/TSE.2019.2961897 - Abate A et al. (2019). Automated Formal Synthesis of Provably Safe Digital Controllers for Continuous Plants. Acta Informatica, vol 57. 10.1007/s00236-019-00359-1 - Almeida et al. (2019). Machine-Checked Proofs for Cryptographic Standards: Indifferentiability of Sponge and Secure High-Assurance Implementations of SHA-3. CCS 2019. 10.1145/3319535.336321

1 1

Re: [Haskell-cafe] [Haskell] [ANNOUNCE] GHC 9.2.3 released
by Shayne Fletcher 28 May '22

28 May '22

there are already tickets covering this see https://gitlab.haskell.org/ghc/ghc/-/issues/21633 & -- https://gitlab.haskell.org/ghc/ghc/-/issues/21634. i have found that `allow-newer:true` and `resolver: nightly-2022-05-27` in `hadrian/stack.yaml` provides a workaround for the moment. On Fri, May 27, 2022 at 7:08 PM George Colpitts <george.colpitts(a)gmail.com> wrote: > Hi > > https://gitlab.haskell.org/ghc/ghc/-/issues/21506, ghc-9.4.1-alpha1 does > not install on macos, exists on 9.2.3 also. The workaround given in 21506 > works. Do you want a ticket for this? > > Thanks > George > > > On Fri, May 27, 2022 at 4:41 PM Zubin Duggal <zubin(a)well-typed.com> wrote: > >> >> The GHC developers are very happy to at announce the availability of GHC >> 9.2.3. Binary distributions, source distributions, and documentation are >> available at [`downloads.haskell.org`]( >> https://downloads.haskell.org/ghc/9.2.3) >> >> Download Page: https://www.haskell.org/ghc/download_ghc_9_2_3.html >> Blog Post: >> https://www.haskell.org/ghc/blog/20220527-ghc-9.2.3-released.html >> >> This release includes many bug-fixes and other improvements to 9.2.2 >> including: >> >> * A fix to a critical linking bug on Windows causing the 9.2.2 release >> to be unusable (#21196). >> >> * Numerous bug fixes for regressions and other issues in the >> typechecker (#2147, #21515, #20582, #20820, #21130, #21479). >> >> * Correctness bugs in the code generator and compiler backends (#21396, >> #20959, #21465). >> >> * Packaging fixes on many platforms (#20760, #21487, #21402). >> >> * Many others. See the [release notes][] for a full list. >> >> As some of the fixed issues do affect correctness users are encouraged >> to upgrade promptly. >> >> We would like to thank Microsoft Azure, GitHub, IOG, the Zw3rk stake >> pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous >> contributors whose on-going financial and in-kind support has >> facilitated GHC maintenance and release management over the years. >> Finally, this release would not have been possible without the hundreds >> of open-source contributors whose work comprise this release. >> >> As always, do give this release a try and open a [ticket] if you see >> anything amiss. >> >> Happy compiling, >> >> - Zubin >> >> >> [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new >> [release notes]: >> https://downloads.haskell.org/ghc/9.2.3/docs/html/users_guide/9.2.3-notes.h… >> _______________________________________________ >> ghc-devs mailing list >> ghc-devs(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs >> > _______________________________________________ > ghc-devs mailing list > ghc-devs(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs > -- Shayne Fletcher

1 1

[Haskell] [ANNOUNCE] GHC 9.2.3 released
by Zubin Duggal 27 May '22

27 May '22

The GHC developers are very happy to at announce the availability of GHC 9.2.3. Binary distributions, source distributions, and documentation are available at [`downloads.haskell.org`](https://downloads.haskell.org/ghc/9.2.3). Download Page: https://www.haskell.org/ghc/download_ghc_9_2_3.html Blog Post: https://www.haskell.org/ghc/blog/20220527-ghc-9.2.3-released.html This release includes many bug-fixes and other improvements to 9.2.2 including: * A fix to a critical linking bug on Windows causing the 9.2.2 release to be unusable (#21196). * Numerous bug fixes for regressions and other issues in the typechecker (#2147, #21515, #20582, #20820, #21130, #21479). * Correctness bugs in the code generator and compiler backends (#21396, #20959, #21465). * Packaging fixes on many platforms (#20760, #21487, #21402). * Many others. See the [release notes][] for a full list. As some of the fixed issues do affect correctness users are encouraged to upgrade promptly. We would like to thank Microsoft Azure, GitHub, IOG, the Zw3rk stake pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket] if you see anything amiss. Happy compiling, - Zubin [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new [release notes]: https://downloads.haskell.org/ghc/9.2.3/docs/html/users_guide/9.2.3-notes.h…

1 0

GHC.X.Hackage and GHC's release cycle
by Ben Gamari 27 May '22

27 May '22

Hello all, Recently in the Haskell Foundation's stability working group we have been discussing various practical issues that Haskell users and prospective adopters encounter around the ecosystem. During these discussions the topic of GHC's release schedule and the ecosystem's process migration to new GHC releases has come up repeatedly. To address some of these issues, I have opened a pair of somewhat-related HF Tech Proposals: * the GHC.X.Hackage proposal ([ghc.x.hackage]) seeks to extend the [head.hackage] infrastructure used to test GHC to enable use by library maintainers in porting and testing their libraries on new GHC releases. * the [tick-tock] release proposal seeks to provide better guidance to users needing long release lifecycles by designating every other release as a "long-term support" release, with 18-month backport window. Given the wide applicability of these proposals we hope to gather feedback from a broad swath of the community. If you have questions, opinions, or concerns on either, please leave your feedback on the respective proposal. We look forward to hearing from you. Thanks! - Ben [ghc.x.hackage]: https://github.com/haskellfoundation/tech-proposals/pull/27 [head.hackage]: https://ghc.gitlab.haskell.org/head.hackage/ [tick-tock]: https://github.com/haskellfoundation/tech-proposals/pull/34

1 0

Should there be a haskell template for inclusion polymorphism in Haskell?
by Miao ZhiCheng 27 May '22

27 May '22

Hi Haskellers! Here are some of my thoughts about polymorphism in Haskell especially the inclusion polymorphism, with questions in the end. ~IGNORE THESE LHS BOILER PLATES~ > {-# LANGUAGE GADTs #-} > module Main where > import Unsafe.Coerce ( unsafeCoerce ) ~IGNORE THESE LHS BOILER PLATES~ * Classification of Polymorphism Let's assume that we are following the classification of polymorphism where there are four types of it: ?? Btw, does anyone have a good citation of this classification? I got it from all over the Internet instead: e.g https://www.tutorialspoint.com/types-of-polymorphisms-ad-hoc-inclusion-para… ** Overloading Polymorphism It allows function with same name to act in different manner for different types. ** Coercion Polymorphism Also called as casting sometimes. ** Inclusion Polymorphism Also called as subtyping. This allows to point derived classes using base class pointers and references. ** Parametric Polymorphism Also called early Binding, it allows to use same piece of code for different types. We can get it by using templates. ** Sub Classifications In terms of being ad-hoc or universal: - Overloading and Coercion are ad-hoc, - Inclusion and Parametric are universal. In terms of being compile-time vs run-time: - Coercion, Overloading, Parametric are all compile-time polymorphism, - while only Inclusion is run-time polymorphism. * Different Polymorphism in Haskell In terms of their counter parties in Haskell language: ** Overloading Polymorphismin Haskell I think type classes basically provides such overloading ad-hoc polymorphism. Some thinks so too: https://stackoverflow.com/questions/6636107/how-does-haskell-handle-overloa… > class Fooable a where > foo :: a -> Int > instance Fooable Int where > foo = id > instance Fooable Bool where > foo _ = 42 ** Coercion Polymorphism in Haskell I think Haskell has both `Coercible` & `unsafeCoerce` for handling representational equality in compile time. But I am not sure if c/c++ style of conercion between similar types such as int/float/double is something Haskell would want to inject these magic conversion code ever. ** Parametric Polymorphism in Haskell This is probably what Haskell is best at the most, demonstrated by the classic `map` function definition: > map' :: (a -> b) -> [a] -> [b] > map' _ [] = [] > map' f (x:xs) = f x : map' f xs Note that, one could also combine parametric and overloading together using constraints: > double :: Num a => a -> a > double x = x + x This `double` function is parametric, but constrained only to work with Num type classes, hence their implementations are overloaded. ** Inclusion Polymorphism in Haskell Ok, finally inclusion polymorphism is what I want to focus on and have some questions here. Before that, I do want to mention one observation, inclusion polymorphism probably is most likely the old OOP habits that die hard. For me at least, since I consider myself a recovering OOP run-time polymorphism addict, and my guess is that unless the use case do need run-time polymorphism, e.g. run-time execution layer abstration, it is often better off using other type of polymorphism to achieve the same result. And even Bjarne Stroustrup is flirting with the idea: [[https://www.youtube.com/watch?v=xcpSLRpOMJM][Bjarne Stroustrup - Object Oriented Programming without Inheritance - ECOOP 2015]] Let's think of translating this piece of pseudo OOP style code into haskell. ``` interface Num { Num (+)(Num a, Num b); Num (*)(Num a, Num b); Num abs(Num a); Num negate(Num a); Num signum(Num a); Num fromInteger(Integer); } interface Show { String show(Show a); } class AnyNum<T> implements Num, Show { // trivially implements Num Show interfaces } // Now we can use AnyNum<Int>, AnyNum<Double>, etc. through their Num or Show interfaces. ``` In Haskell though, thanks to the ability of having existential type, AnyNum is actually quite nice to write: > data AnyNum where > MkAnyNum :: (Num a, Show a) => a -> AnyNum But in order to use AnyNum like using interfaces in our pseudo code, we would have to write these boiler plates and in some cases using unsafeCoerce due to not using Typeable run-time information: > instance Num AnyNum where > (+) (MkAnyNum a) (MkAnyNum b) = MkAnyNum $ a + unsafeCoerce b > (*) (MkAnyNum a) (MkAnyNum b) = MkAnyNum $ a + unsafeCoerce b > abs (MkAnyNum a) = MkAnyNum . abs $ a > negate (MkAnyNum a) = MkAnyNum . negate $ a > signum (MkAnyNum a) = MkAnyNum . signum $ a > fromInteger = MkAnyNum . fromInteger > instance Show AnyNum where > show (MkAnyNum a) = show a Here is some test code that demonstrate how distressful unsafeCoerce is: > main = do > let a = MkAnyNum(1 :: Int) > let b = MkAnyNum(2 :: Double) > let c = MkAnyNum(3 :: Int) > print $ show $ a + b > print $ show $ a + c Outputs are: ``` λ> "4611686018427387905" "4" ``` Few observations: - If there is at most one occurance of the usage of the type class, there is no need for the unsafeCoerce. - Otherwise, unsafeCoerce is required, or otherwise those functions could be left to "undefined". So my central questions for discussions are: - Is inclusion polymorphism something we should use at all in Haskell? - These boiler plate code maybe better be generated using Haskell template instead, is there one already, or should there be one? Cheers, Miao

2 2

GHC 9.4.1-alpha2 now available
by Ben Gamari 24 May '22

24 May '22

The GHC developers are happy to announce the availability of the second alpha release of the GHC 9.4 series. Binary distributions, source distributions, and documentation are available at downloads.haskell.org: https://downloads.haskell.org/ghc/9.4.1-alpha2 This major release will include: - A new profiling mode, `-fprof-late`, which adds automatic cost-center annotations to all top-level functions *after* Core optimisation has run. This incurs significantly less performance cost while still providing informative profiles. - A variety of plugin improvements including the introduction of a new plugin type, *defaulting plugins*, and the ability for typechecking plugins to rewrite type-families. - An improved constructed product result analysis, allowing unboxing of nested structures, and a new boxity analysis, leading to less reboxing. - Introduction of a tag-check elision optimisation, bringing significant performance improvements in strict programs. - Generalisation of a variety of primitive types to be levity polymorphic. Consequently, the `ArrayArray#` type can at long last be retired, replaced by standard `Array#`. - Introduction of the `\cases` syntax from [GHC proposal 0302] - A complete overhaul of GHC's Windows support. This includes a migration to a fully Clang-based C toolchain, a deep refactoring of the linker, and many fixes in WinIO. - Support for multiple home packages, significantly improving support in IDEs and other tools for multi-package projects. - A refactoring of GHC's error message infrastructure, allowing GHC to provide diagnostic information to downstream consumers as structured data, greatly easing IDE support. - Significant compile-time improvements to runtime and memory consumption. - On overhaul of our packaging infrastructure, allowing full traceability of release artifacts and more reliable binary distributions. - ... and much more. See the [release notes] for a full accounting. Note that, as 9.4.1 is the first release for which the released artifacts will all be generated by Hadrian, it's possible that there will be packaging issues. If you enounter trouble while using a binary distribution, please open a [ticket]. Likewise, if you are a downstream packager, do consider migrating to [Hadrian] to run your build; the Hadrian build system can be built using `cabal-install`, `stack`, or the in-tree [bootstrap script]. We would like to thank Microsoft Azure, GitHub, IOHK, the Zw3rk stake pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket] if you see anything amiss. Happy testing, - Ben [GHC proposal 0302]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0302-c… [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new [bootstrap script]: https://gitlab.haskell.org/ghc/ghc/-/blob/e2520df3fffa0cf22fb19c5fb872832d1… [release notes]: https://downloads.haskell.org/~ghc/9.4.1-alpha2/docs/users_guide/9.4.1-note…

2 1

ANN: haskell-links.org - searchable links db
by Simon Michael 21 May '22

21 May '22

Hello Haskell friends, Recently I said this on reddit: > There's no way these very frequent reddit and chat requests for learning materials can capture all the existing resources. There are too many, and folks who know where they are get burned out reposting them. There have been many attempts to gather them, haskell.org/documentation being the most obvious, but none of them have fully succeeded. We could really do with some more systematic, scalable (crowd-sourced, lightweight) approach. Then I experimented and set up https://haskell-links.org . This is version 1, providing: - A searchable read-only view of the Haskell links collected by lambdabot, the popular #haskell IRC bot. - A redirector/link shortener/memory aid, for jumping to any of these links via their short ID. Eg: https://haskell-links.org/doc <https://haskell-links.org/doc> https://haskell-links.org/books <https://haskell-links.org/books> https://haskell-links.org/ghc-guide <https://haskell-links.org/ghc-guide> - Collected links to other Haskell search tools, making this a fast way to get to anywhere in Haskelldom. After contemplation and discussion on #haskell, I believe version 2 should allow web editing and use its own database. But I wanted to share this one as it's a nice simple setup. I hope you might find useful ! Help is welcome, see README. Best, -Simon

2 2

[ANN]: simfin 1.0.0 - Simple financial data API wrapper
by Owen Shepherd 21 May '22

21 May '22

Hello everyone, I've released a small library that wraps the SimFin (https://simfin.com/) API. SimFin collates and organises financial data, and provides a nice little web API which provides historical prices, ratios, financial statement extracts, etc. Hackage link: https://hackage.haskell.org/package/simfin-1.0.0 Enjoy, - Owen

1 0

[template haskell] Sharing names between constructors and types
by Patrick L Redmond 20 May '22

20 May '22

Hello Haskell Cafe, When can a type not share the name of a constructor? Defining a type and a constructor with the same name, manually, as follows, seems to be acceptable: data F = F | T data T However, if the type is generated by Template Haskell, it is no longer acceptable, as follows: voidType :: Name -> DecsQ voidType n = do d <- dataD (return []) n [] Nothing [] [] return [d] In a separate module: data F = F | T $(voidType 'T) This will result in a "Multiple declarations of ‘T’" error. Is this expected? Thank you, Patrick

2 2

Package takeover request for rapid
by Markus Läll 19 May '22

19 May '22

Hi I would like to take over https://hackage.haskell.org/package/rapid The author of the package Ertugrul Söylemez, once an active member of the community perhaps best known for netwire, passed away in 2018. [1] The work required for the package thus far, and for which I've kept a fork for, is to bump version bounds as GHCs progress. [1] https://github.com/esoeylemez/rapid/pull/2#issuecomment-427065739 -- Markus Läll

5 7

ML Family Workshop 2022: Final Call for Presentations
by Benoit Montagu 17 May '22

17 May '22

We are happy to invite submissions to the ML Family Workshop 2022, to be held during the ICFP conference week on Thursday, September 15th. The ML family workshop warmly welcomes submission touching on the programming languages traditionally seen as part of the “ML family” (Standard ML, OCaml, F#, CakeML, SML#, Manticore, MetaOCaml, etc.). The scope of the workshop includes all aspects of the design, semantics, theory, application, implementation, and teaching of the members of the ML family. We also encourage presentations from related languages (such as Haskell, Scala, Rust, Nemerle, Links, Koka, F*, Eff, ATS, etc), to exchange experience of further developing ML ideas. The workshop does not have proceedings, making it the perfect venue to run some ideas with the community or present some work in progress within a friendly environment. The PC has a broad expertise and submissions are 3 pages long: when in doubt, just submit! Currently, the workshop is scheduled to be an in-person event. We will give to the authors of accepted abstracts the opportunity to give their talks remotely if necessary, in case they could not travel. See the detailed CFP online on the ICFP website: https://icfp22.sigplan.org/home/mlfamilyworkshop-2022#Call-for-Presentations Important dates --------------- Friday 3th June (any time zone): Abstract submission deadline Tuesday 28th June: Author notification Thursday 15th August: ML Family Workshop Program committee ----------------- Kenichi Asai (Ochanomizu University) Arthur Azevedo de Amorim (Boston University) Dariusz Biernacki (University of Wrocław) Stephen Dolan (Jane Street) Kavon Farvardin (Apple) Armaël Guéneau (Inria) Sam Lindley (University of Edinburgh) Guido Martínez (CIFASIS-CONICET) Keiko Nakata (SAP Innovation Center Potsdam) Lionel Parreaux (Hong Kong University of Science and Technology) Matija Pretnar (University of Ljubljana) Mike Rainey (Carnegie Mellon University) Yann Régis-Gianas (Nomadic Labs) KC Sivaramakrishnan (IIT Madras and Tarides) Ningning Xie (University of Cambridge) Chair: Benoît Montagu (Inria) Submission details ------------------ See the online CFP for the details on the expected submission format. Submissions must be uploaded to the workshop submission website https://ml2022.hotcrp.com/ before the submission deadline.

1 0

Assistant Professorships in Nottingham
by Graham Hutton 17 May '22

17 May '22

Dear all, As part of a strategic expansion, the School of Computer Science at the University of Nottingham is seeking to make multiple new appointments at the Assistant Professor level: https://tinyurl.com/38f753d5 These positions are aimed at early career academics who recently completed or will soon complete their PhD, and have a reduced teaching responsibility for the first three years. Applications in the area of the Functional Programming (FP) lab are strongly encouraged! The FP lab is keen to receive applications from candidates with a strong publication record (e.g. papers in leading venues such as LICS, POPL, ICFP, JFP, TOPLAS, etc) and the potential to secure external funding. The group recently grew its profile in type theory with the appointment of Nicolai Kraus and Ulrik Buchholtz. To complement these appointments, we particularly welcome applications from candidates who would bring further or other areas of expertise. Further information about the FP lab is available from: https://tinyurl.com/y2ekdkqa The deadline for applications is Tuesday 24th May 2022. -- Graham Hutton and Thorsten Altenkirch 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

Haskellers needed @ Superrare Labs
by Ruben Astudillo 13 May '22

13 May '22

Hello haskell-cafe . I have been working with SuperRare Labs for more than a year and they are looking to grow the team! I know the feelings of the community about NFTs and Blockchains. Those arguments have been said (and said better!) for example on the haskell sub-reddit. Still, I think there are neat pieces of technology on our backend and we have a good work environment where we can do some neat engineering. SuperRare labs is a US based company with US level compensation, fully remote (I am Chilean and I feel in-the-loop). Technology wise we are into Haskell, GraphQL (template haskell interop), `extensible`-records, Postgresql and hs-web3[0]. If any of those technologies interest you, _please_ send a message at the forms at greenhouse[1], in particular on the backend engineer role. Also, send me a private email so we can chat, answer your questions and/or see ways to speed up the process. [0]: <https://hackage.haskell.org/package/web3> [1]: <https://boards.greenhouse.io/superrarelabs> -- Rubén. (pgp: 1E88 3AC4 89EB FA22)

1 0

Final call for participation: Advanced Functional Programming Summer School in Utrecht
by Swierstra, W.S. (Wouter) 13 May '22

13 May '22

# Call for Participation SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING Utrecht, the Netherlands, 04 July – 08 July 2022 http://www.afp.school **Please register before June 17th ** ## ABOUT The Advanced Functional Programming summer school has been running for more than ten years. We aim to educate aspiring Haskell programmers beyond the basic material covered by many textbooks. After running remotely for the past two years, we're thrilled to announce that this year's edition will take place on site in Utrecht. We are monitoring the pandemic closely - and will make contingency plans if we cannot meet in person; at the moment, we do not have plans for remote participation. The lectures will cover several more advanced topics regarding the theory and practice of Haskell programming, including topics such as: * lambda calculus; * monads and monad transformers; * lazy evaluation; * generalized algebraic data types; * type families and type-level programming; * concurrency and parallelism. The summer school consists of a mix of lectures, labs, and a busy social program. ## LECTURERS Utrecht staff: * Gabriele Keller * Trevor McDonell * Wouter Swierstra ## PREREQUISITES We expect students to have a basic familiarity with Haskell already. You should be able to write recursive functions over algebraic data types, such as lists and trees. There is a great deal of material readily available that covers this material. If you've already started learning Haskell and are looking to take your functional programming skills to the next level, this is the course for you. ## DATES **Registration deadline: June 17th, 2022** School: 04 July – 08 July 2022 ## COSTS 750 euro - Profession registration only 250 euro - Student registration fee 200 euro - Housing fee We will charge a registration fee of 750 euros (or 250 euros for students) to cover our expenses. If this is problematic for you for any reason at all, please email the organisers and we can try to offer you a discounted rate or a fee waiver. We have a limited number of scholarships or discounts available for students that would not be able to attend otherwise, especially for women and under-represented minorities. ## FURTHER INFORMATION Further information, including instructions on how to register, is available on our website: http://www.afp.school

1 0

profiling cpu usage of concurrent program
by Olaf Klinke 12 May '22

12 May '22

Dear Café, I have a network application of which I would like to know which parts are responsible for the majority of CPU usage. Conventional GHC profiling does not quite work here, because 1. +RTS -p shows that the program spends most of its *time* idling, where cost centers of interest are so insignificant that the precision of %time in the .prof format make it impossible to determine the relative execution time of selected cost centers. The Wiki [1] suggests the -P option. 2. Even ThreadScope (haven't tried yet) may show me only what's expected: The work is done in worker threads. I am not so much concerned about the level of concurrency or parallelism, but which parts occupy the cpu. I ran the program with +RTS -P and sorted the output by ticks. Naturally, functions like threadDelay and liftIO come at the top. But these all stand for waiting IO actions. As first approximation, I might ignore these and consider the remainder. Is that a valid approach? Is there a profiler that measures something like CPU cycles per cost center? Should I turn to ghc-events-analyze [2]? Or perf? Execution time is not critical (as long as the queue is emptied faster than data is flowing in) but maxing out the computing resources may become critical because it mandates more expensive hardware. I've been pitching Haskell to my bosses by promising better performance (compared to Python). Appropriate profiling seems essential to keep that promise. Olaf [1] https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.h… [2] https://hackage.haskell.org/package/ghc-events-analyze

1 0

Call for Reviewers APLAS 2022 Artifact Evaluation Committee
by Arpita Dutta 12 May '22

12 May '22

Dear all; The /20th Asian Symposium on Programming Languages and Systems/ (APLAS'22) is going to be holding its first /Artifact Evaluation Committee/ (AEC). The artifact evaluation process aims to promote, share, and catalogue the research artifacts of papers accepted to the APLAS research track. We are looking for motivated researchers at all academic stages (PhD Students, Researchers, Lecturers, & Professors) to join us on the inaugural APLAS'22 AEC. The self-nomination form is available at: https://forms.gle/rJREG9DiFQHegZmD9 To nominate other people please use the following form: https://forms.gle/KFiQYLjELMsEjGLp8 As a committee member your primary responsibility will be to review artifacts submitted by authors of accepted papers and ensure that the artifact is a faithful representation of the accepted paper's results. This will involve interacting with some tooling provided by the authors, check if the results of the main paper are consistent with the claims in the paper and are also reproducible for researchers to come. APLAS will use a three-phase artifact review process: Kick-The-Tyres; Review the Artifact; and Iron-out-the-Wrinkles. Reviewing guidance for committee members will be made available once the committee has been formed. We will close nominations on: Friday 08 July 2022 (AOE) and notify the selected committee members on: Friday 15 July 2022 (AOE) We expect most of the reviewing process to be performed between 22nd August 2022 and 19th September 2022. We expect each artifact to take around eight hours to review and we will look to assign each reviewer three to four reviews. For each artifact we will assign a Lead Reviewer to lead the reviewing process. Salient information about the reviewing process can be found online: https://2022.splashcon.org/track/aplas-2022-aec#Reviewer-Information<https://2022.splashcon.org/track/aplas-2022-aec#Reviewer-Information> Come join us to improve the quality of research in our field! Thanks Arpita Dutta and Jan de Muijnck-Hughes APLAS'22 AEC Co-Chairs. This call was adapted from the PLDI'22 AEC Call for Nominations.

1 0

BX 2022 - Call for papers (deadline 14 May)
by Li-yao Xia 10 May '22

10 May '22

# Tenth International Workshop on Bidirectional Transformations (BX 2022) 8 July 2022, Nantes, France Part of STAF 2022 (5-8 July): https://staf2022.univ-nantes.io/ BX 2022 homepage: http://bx-community.wikidot.com/bx2022:home ## Overview Bidirectional transformations (BX) are a mechanism for maintaining the consistency between two or more related (and heterogeneous) sources of information (e.g., relational databases, software models and code, or any other artefacts following standard or domain-specific formats). The strongest argument in favour of BX is its ability to provide a synchronization mechanism that is guaranteed to be correct by construction. BX has been attracting a wide range of research areas and communities, with prominent presence at top conferences in several different fields (namely databases, programming languages, software engineering, and graph transformation). Nowadays, the fast-growing complexity of software- or data-intensive systems has forced industry and academia to use and investigate different development techniques to manage the many different aspects of the systems. Researchers are actively investigating the use of bidirectional approaches to tackle a diverse set of challenges with various applications including model-driven software development, visualization with direct manipulation, big data, databases, domain-specific languages, serializers, and data transformation, integration and exchange. BX 2022 is a dedicated venue for BX in all relevant fields and is part of a workshop series that was created in order to promote cross-disciplinary research and awareness in the area. As such, since its beginning in 2012, the workshop has rotated between venues in different fields. Papers for BX 2022 can be submitted on EasyChair: https://www.easychair.org/conferences/?conf=bx2022 ## Important Dates - Paper submission: 14 May, 2022 - Author notification: 28 May, 2022 - Workshop: 8 July, 2022 ## Topics The aim of the workshop is to bring together researchers and practitioners, established and new, interested in bx from different perspectives, including but not limited to: - bidirectional programming languages and frameworks - software development with BX - data and model synchronization - view updating - inter-model consistency analysis and repair - data/schema (or model/metamodel) co-evolution - coupled software/model transformations - inversion of transformations and data exchange mappings - domain-specific languages for BX - analysis and classification of requirements for BX - bridging the gap between formal concepts and application scenarios - analysis of efficiency of transformation algorithms and benchmarks - model-driven and model-based approaches - survey and comparison of BX technologies - case studies and tool support - applications and experiences of adopting BX in the real world ## Categories of Submissions Five categories of submissions are considered: 1. Full Research Papers (13-15 pages) - in-depth presentations of novel concepts and results - applications of bx to new domains - survey papers providing novel comparisons between existing bx technologies and approaches, case studies 2. Tool Papers (7-8 pages) - guideline papers presenting best practices for employing a specific bx approach (with a specific tool) - presentation of new tools or substantial improvements to existing ones - qualitative and/or quantitative comparisons of applying different bx approaches and tools 3. Experience Report (7-8 pages) - sharing experiences and lessons learned with bx tools/frameworks/languages - how bx is used in (research/industrial/educational) projects 4. Short Papers (5 pages) - work in progress - small focused contributions - position papers and research perspectives - critical questions and challenges for bx 5. Talk Proposals (2 pages) - proposed lectures about topics of interest for bx - existing work representing relevant contributions for bx - promising contributions that are not mature enough to be proposed as papers of the other categories ## Submission guidelines Papers should use the new CEUR-ART style, single column, available as an Overleaf page or as a zip archive: https://www.overleaf.com/read/gwhxnqcghhdt http://ceur-ws.org/Vol-XXX/CEURART.zip and must be submitted via EasyChair: https://www.easychair.org/conferences/?conf=bx2022 If your submission is not a Full Research Paper, please include the intended submission category in the Title field of EasyChair’s submission form. Tool papers, experience reports and short papers will be mapped to the short paper category in CEUR (having between 5-9 standard pages, 1 standard page = 2500 characters), whereas full research papers will be mapped to the regular paper category in CEUR (having at least 10 standard pages). The bibliography is excluded from the page limits. All papers are expected to be self-contained and well-written. Tool papers are not expected to present novel scientific results, but to document artifacts of interest and share bx experience/best practices with the community. Experience papers are expected to report on lessons learnt from applying bx approaches, languages, tools, and theories to practical application case studies. Extended abstracts should primarily provoke interesting discussion at the workshop and will not be held to the same standard of maturity as regular papers; short papers contain focused results, positions or perspectives that can be presented in full in just a few pages, and that correspondingly contain fewer results and that therefore might not be competitive in the full paper category. Talk proposals are expected to present work that is of particular interest to the community and worth a talk slot at the workshop. We strongly encourage authors to ensure that any (variants of) examples are present in the bx example repository at the time of submission, and, for tool papers, to allow for reproducibility with minimal effort, either via a virtual machine (e.g., via Share) or a dedicated website with relevant artifacts and tool access. All papers will be peer-reviewed by at least three members of the program committee. If a submission is accepted, at least one author is expected to participate in the workshop to present it. Authors of accepted tool paper submissions are also expected to be available to demonstrate their tool at the event. ## Proceedings The workshop proceedings (in a STAF 2022 joint volume for workshops), including all accepted papers (except talk proposals), shall be submitted after the conference to CEUR-WS.org for online publication. Pre-prints of all papers will be available via the workshop website at the beginning of the conference. In case of questions, please contact the PC chairs at bx2022(a)easychair.org. Best regards, Li-yao Xia, Vadim Zaytsev, Xiao He

1 1

Full professorships at Utrecht University
by Swierstra, W.S. (Wouter) 10 May '22

10 May '22

Utrecht University is currently recruiting four full professors in Computing Science. The exact research areas are not fixed -- but I'd love to see applications from the functional programming community: https://www.uu.nl/en/organisation/working-at-utrecht-university/jobs/4-full… # Job description The Department of Information and Computing Sciences (ICS) is nationally and internationally renowned for its fundamental and applied research in computer science and information science. In our constantly changing (digital) society, we are continually looking for new, realistic ways to push the boundaries of both science and societal application. We contribute to innovative information technologies through the development and application of new concepts, theories, algorithms, and software methods. With our expertise, we nourish a wide range of interdisciplinary and societal collaboration initiatives. The Department has grown significantly in the past years. Due to this growth and the upcoming retirement of some of our professors we envisage having appointed eight new full professors by the end of 2024 in the following fields of expertise: software systems (preferably in software production, and software and information security), artificial intelligence and data science (preferably in machine learning, responsible AI, and natural Language processing) and interaction (preferably in data-driven interaction). We are now actively searching to fill four positions. Since we aim to continue to increase the participation of women in Information and Computing Sciences (both students and staff), we wish to appoint at least two female full professors. Additionally, we have one position open that is not tied to any specific area, exclusively reserved for female candidates, a Westerdijk chair*. In Software Systems, we have research groups on Software Technology, Software Technology for Teaching and Learning, Software Production, and Business Process Management and Analytics. We lead the research masters on Computing Science and Business Informatics, and co-lead the bachelors Informatics and Information Science. We engage closely with industry and public sector partners to study the development and adoption of software technology and software production methods. In Artificial Intelligence & Data Science, we have research groups on Intelligent Systems, Data Intensive Systems, Data Mining, and Natural Language Processing. We lead the multidisciplinary research master in Artificial Intelligence and Data Science, and co-lead the Applied Data Science master and Artificial Intelligence bachelor. We closely collaborate with the public sector and companies, for example in our National Police Lab AI and AI & Mobility Lab. We also work closely with other disciplines, for example in the university's Human Centered AI and Applied Data Science focus areas. In Interaction Technology, we have research groups on Human Centered Computing, Game and Media Technology, Social and Affective Computing, and Visualisation and Graphics. We lead the Research Masters on Game & Media Technology and Human-Computer Interaction, and co-lead the Bachelor Information Science. Our state-of-the-art facilities include a Human-Centered Computing lab for prototyping interactive systems and conducting user studies and a Motion Capture and Virtual Reality Lab with full body motion capture equipment. We co-lead the multidisciplinary AI & Media and AI & Healthy Living labs and the Center for Game Research. As a full professor you are a committed, internationally acknowledged and leading scientist with expertise in one of the areas of Information and Computing Science. Your ambition is to lead the further development of research, the quality of education (both in teaching and curriculum development) and the achievement of societal impact in the field of information and computing sciences. You seek internal and external (interdisciplinary) collaboration and acquire funding for research, developing new research collaborations and new application areas. You are an inspiring educator with enthusiasm for teaching. Alongside you will take a leading role in your field of expertise, you also play an important role in creating a workplace that is supportive, socially safe and inclusive, further enhancing scientific integrity and working together towards open science. You have a clear view of how to achieve this as a leading staff member. The Department provides a dynamic, informal and international work environment. Our approach is characterized by a connected, open, and can-do spirit that stimulates personal initiative and curiosity. You are a team player who encourages taking ownership and create value while sharing your knowledge both internally and across the wider (global) community. If you are excited to actively participate and collaborate in shaping our developing department, we invite you to apply. It is important that when you apply, you make clear where and how you see that your expertise fits the overall research and education portfolio of the department, including the relationship with (future) external stakeholders. *A Westerdijk chair is a position especially installed to be occupied by a female professor. It is named after Johanna Westerdijk, appointed at Utrecht University in 1917 as the first female full professor in the Netherlands. # Qualifications We are looking for new colleagues to complement our team at an academic as well as a personal level, who fit well with the following qualifications: a PhD in Computer Science, Information Science or another relevant discipline; an internationally acknowledged research line with a strong publication track record on original research of high impact; an active player in international scientific communities; experience in and a personal view on how to lead a group of scientists and create and sustain a supportive, collaborative and inclusive work environment; demonstrated ability to acquire external funding for research and innovation; driven to explore and forge new collaborations in- and outside academia; enthusiasm for education and experience with student supervision, ability to teach in BSc and MSc programmes; experience in and aspiration for further development of courses and programmes. # Offer a tenured position as full professor; a full-time gross salary ranging from €5,864 to €8,539 in scale H2 at full professor level; benefits including an 8% holiday bonus and an 8.3% end-of-year bonus; a pension scheme, partially paid parental leave, and flexible employment conditions based on the Collective Labour Agreement (cao) Dutch Universities; a starting package that is negotiable and depends on what is necessary to give you a running start in the department; assistance in finding housing and, if applicable, help with finding employment for a partner and schools for children; in addition to the employment conditions laid down in the CAO for Dutch Universities, Utrecht University has a number of its own arrangements. For example, there are agreements on professional development, leave arrangements and sports. We also give you the opportunity to expand your terms of employment via the Employment Conditions Selection Model. This is how we like to encourage you to continue to grow. # About the organisation At the Faculty of Science, there are 6 departments to make a fundamental connection with: Biology, Chemistry, Information and Computing Sciences, Mathematics, Pharmaceutical Sciences, and Physics. Each of these is made up of distinct institutes that work together to focus on answering some of humanity’s most pressing problems. More fundamental still are the individual research groups – the building blocks of our ambitious scientific projects. Utrecht University is a friendly and ambitious university at the heart of an ancient city. We love to welcome new scientists to our city – a thriving cultural hub that is consistently rated as one of the world’s happiest cities. We are renowned for our innovative interdisciplinary research and our emphasis on inspirational research and excellent education. We are equally well-known for our informal atmosphere and the can-do mentality of our people. This lively and inspiring academic environment attracts professors, researchers and PhD candidates from all over the globe, making both the University and the Faculty of Science a vibrant international and wonderfully diverse community. # Additional information If you have specific questions regarding the positions or the department, please email them to Professor Johan Jeuring (Head of Department) or Professor Judith Masthoff (Director of Research) at j.t.jeuring(a)uu.nl/ j.f.m.masthoff(a)uu.nl. If you are interested in reading more about the development of our department, we can provide you with a copy of our summarized organizational development plan. You can send your request to a.bonsma(a)uu.nl. Do you have a question about the application procedure? Please send an email to science.recruitment(a)uu.nl # Apply https://ssl1.peoplexs.com/Peoplexs22/CandidatesPortalNoLogin/ApplicationFor… Everyone deserves to feel at home at our university. We welcome employees with a wide variety of backgrounds and perspectives. Please enclose: your motivation letter; your full academic curriculum vitae, including a list of publications; your vision on research and education. If this specific opportunity isn’t for you, but you know others who may be interested, please forward this vacancy to them. The application deadline is 1 July 2022.

1 0

[direct-sqlite] Package takeover
by ☂Josh Chia (謝任中) 09 May '22

09 May '22

Hi all, I tried to contact the author of https://hackage.haskell.org/package/direct-sqlite via github issues and direct email 27 days ago about taking over the package but have not received a response. I would like to take over as maintainer for the package and would also welcome co-maintainers. Josh Chia

1 0

cabal v2 global install status
by amindfv＠mailbox.org 09 May '22

09 May '22

I'm very comfortable using cabal's `v2-` nix-style local builds at home and at work, but on a personal machine at home I've clung to `v1-install` because I _really_ like the ability to choose which packages are available in a simple `ghci` session. For a long time that's been impossible or painful with the `v2-` commands. What's the status these days? I'm particularly interested in how it works for packages that only exist locally without a Hackage server. (Please note that while I'm open to hearing that it's impossible or only possible with workarounds/hacks, I'm not particularly looking for a discussion on whether it's "wrong" to want this feature.) Thanks! Tom

7 11

Coverage icon on hackage
by Ivan Perez 08 May '22

08 May '22

Hi all, What analysis does the hackage server run to determine the coverage level of, or rating given to, a particular package? For example, for one package it is showing this icon: https://img.shields.io/static/v1?label=Coverage&message=32%&color=red What does that actually mean? The build log states: Code Coverage expressions 32% (224/684) booleanguards 100% (0/0) conditions 20% (1/5) qualifiers 100% (0/0) alternatives 27% (5/18) local declarations 40% (6/15) top-level declarations 32% (29/90) Is it possible to see details of how hackage is arriving to these conclusion, and to replicate these results locally? Thanks, Ivan

3 4

[ANN] mtl-2.3
by Emily Pillmore 08 May '22

08 May '22

Hello Everyone, mtl-2.3 has been released. This release marks the first major version for the library in a long time, and addresses some longstanding issues that have taken years to fix. As a result, this will be a *breaking update* for many. Please review the following changelog notes: * Added instances for Control.Monad.Trans.Writer.CPS and Control.Monad.Trans.RWS.CPS from transformers 0.5.6 and add Control.Monad.Writer.CPS and Control.Monad.RWS.CPS. * Control.Monad.Cont now re-exports evalCont and evalContT. * Add tryError , withError , handleError , and mapError to Control.Monad.Error.Class , and re-export from Control.Monad.Except. * Remove Control.Monad.List and Control.Monad.Error. * Remove instances of deprecated ListT and ErrorT. * Remove re-exports of Error. * Add instances for Control.Monad.Trans.Accum and Control.Monad.Trans.Select ( http://control.monad.trans.select/ ). * Require GHC 8.6 or higher, and cabal-install 3.0 or higher. * Require transformers-0.5.6 or higher. * Add Control.Monad.Accum for the MonadAccum type class, as well as the LiftingAccum deriving helper. * Add Control.Monad.Select ( http://control.monad.select/ ) for the MonadSelect type class, as well as the LiftingSelect deriving helper. A big thank you to all contributors and commentators, and a special thanks to Koz for picking up maintenance so swiftly. Happy hacking, Emily

2 1

Re: [Haskell-cafe] data/newtype examples
by Olaf Klinke 07 May '22

07 May '22

> Dear Cafe - > > > I wanted a quick example (for teaching) > that shows a difference between data and newtype. > > What examples do you use? > I'm interested both in simple ones, > and confusing/obfuscated ones. Perhaps on the obscure side: I like to play with different implementations of Void. Let the students demonstrate that newtype Void = Void Void contains only one element whereas data Void = Void Void contains infinitely many elements that can be distinguished by pattern matching. Also consider data Void = Void !Void. Is this observably different from the Void newtype? Since you will have to explain lifting, you can also demonstrate that(,) is not the categorical product. Olaf

1 0

GHC proposal for ImplicitQualifiedImport
by Tristan Cacqueray 07 May '22

07 May '22

Dear Café, I've proposed a new language extensions to enable implicit imports, so that a qualified name can be used without adding an import declaration: https://github.com/ghc-proposals/ghc-proposals/pull/500 Would such an extension makes your life better? I value your feedback, so let me know what you think! Kind Regards, -Tristan

1 0

Was simplified subsumption worth it for industry Haskell programmers?
by pareto optimal 06 May '22

06 May '22

I originally posted on Reddit and the thread contains much debate and discussion. I'm concerned the views of the mailing list and likely ghc devs might not be as represented there or discourse, so i'm also copying it here. Copy-paste of post: Warning: Long post tl;dr - simplified subsumption seems to make common code I write in industry clunky for no good reason in lots of places - Are others concerned with motivating what seem like "pointless lambdas" to new hires or students for simple tasks? - Are there more real world advantages that make these frequent annoyances worth it? - How is quicklook impredicativity useful in industry? The biggest advantage seems to be that laziness is more predictable. However looking at [commits fixing simplified subsumption errors on github](https://github.com/search?q=simplified+subsumption+language%3Ahaske… I see very common patterns in industry Haskell now need an explicit lambda for "reasons" such as: readFreqSumFile :: (MonadSafe m) => FilePath -> m (FreqSumHeader, Producer FreqSumEntry m ()) - readFreqSumFile file = readFreqSumProd $ withFile file ReadMode PB.fromHandle + readFreqSumFile file = readFreqSumProd $ withFile file ReadMode (\h -> PB.fromHandle h) and: - toOrders <- asks _pdfConfToOrder + toOrders <- asks (\r -> _pdfConfToOrder r) And this typical use of id is no longer valid: instance MonadOrvilleControl IO where - liftWithConnection = id - liftFinally = id + liftWithConnection ioWithConn = ioWithConn + liftFinally ioFinally = ioFinally On my $work codebase that means hundreds of changes that make our code worse with seemingly no benefit. This case is addressed in the proposal, but seems to handwave this as: > The benefit, in terms of programming convenience, is small. >From my perspective while updating my codebase, it certainly doesn't feel that way. >From the persective of onboarding new Haskell hires, it doesn't feel simpler. I envision a future teaching session like: > student: This code looks correct but I get an error that means nothing to me of error: • Couldn't match type: b0 -> b0 with: forall q. q -> q Expected: p -> forall q. q -> q Actual: p -> b0 -> b0 • In the first argument of ‘g’, namely ‘f’ In the expression: g f In an equation for ‘h’: h = g f | | h = g f | ^ > me: Ah, that's because of something called simplified subsumption which we'll cover much later. > me: For now, just know putting it in an explicit lambda fixes it when you notice a compile error like that. > me: Now lets try to move past that and get back to basic file reading and writing > student: oookkkay? (feeling unsure, disillusioned about Haskell requiring pointless ceremony and being overly complex for no seeming benefit) Being a fan of and proponent of Haskell I think: If this complication is being added, surely something is made possible in return that gives more value. This led me to [the proposal](https://github.com/ghc-proposals/ghc-proposals/blob/master/propos… and I found with simplified subsumption: - Laziness characteristics and semantics of programs will be changed less, which I infer will lead to more predictable performance - I assume that simplifying a compiler step like this will speed up compile times and reduce space usage - Quick look impredicativity seems to be the real driving reason behind simplified subsumption and somehow makes dealing with very polymorphic code easier At this point my thought is: > Making highly polymorphic code simpler to write that isn't as typical in industry Haskell code in ways I can't determine without great effort was valued over "small incoveniences" that I'll run into daily But, still wanting to give the benefit of the doubt I dive face first into [The proposal for Quicklook impredicativity](https://github.com/ghc-proposals/ghc-proposals/blob/master…. Reading the whole thing, I still cannot ground this concept in real world terms that may effect me or that I could take advantage of. So, I go to the paper [A quick look at impredicativity](https://www.microsoft.com/en-us/research/publication/a-qui… and start reading many things I don't fully understand. Running out of energy, I start skimming and finally find some examples in section 10 APPLICATIONS. I see an example with gZipWithM that I still don't understand. Further down I see reference to pieces of code updated in Streamly that take advantage of quick look polymorphism and wonder why the real world example wasn't included and explained. So, i'm left frustrated with "simplified" subsumption and posting here for help answering: - Are others in the same boat? - Are there advantages i'm not seeing? - Can we use my reflection to improve industry/academic communication? And finally, any revant commentary surrounding this I may be oblivious to. Thanks!

5 5

data/newtype examples
by Johannes Waldmann 06 May '22

06 May '22

Dear Cafe - I wanted a quick example (for teaching) that shows a difference between data and newtype. You'd think that `newtype` makes things more strict, so we'd see more exceptions. Then try the following, and try to guess the semantics beforehand: ghci> data D = D Bool ghci> case D undefined of D x -> () ghci> case undefined of D x -> () ghci> newtype N = N Bool ghci> case N undefined of N x -> () ghci> case undefined of N x -> () What examples do you use? I'm interested both in simple ones, and confusing/obfuscated ones. Yes I know I can ghci> seq (D undefined) () () ghci> seq (N undefined) () *** Exception: Prelude.undefined but that `seq` is extra magic that needs to be explained. Well, perhaps I should. To show that I've done some homework here: the primary source of truth is the Haskell Language Report (well hidden at the bottomest end of https://www.haskell.org/documentation/) and it uses (in 4.2.3 Datatype Renamings) the concept of "equivalent to bottom". Then 6.2 Strict Evaluation shows how to test that with `seq` (without mentioning newtype, and that's fine since the Report is not a tutorial). This suggests that `seq` is really the way to go here. There are examples for data/newtype/case combined in 3.17.2 Informal Semantics of Pattern Matching but they distinguish between newtype N = N Bool and data D = D !Bool (with a bang). - J.W.

2 1

Deadline extension CfP: FMBC 2022 - 4th International Workshop on Formal Methods for Blockchains
by Zaynah Dargaye 04 May '22

04 May '22

FMBC 2022 Deadline Extension Call for Papers [ Please distribute, apologies for multiple postings. ] ======================================================================== 4rd International Workshop on Formal Methods for Blockchains (FMBC) - Deadline Extension Call https://fmbc.gitlab.io/2022 August 11, 2022, Haifa, Israel Co-located with The Federated Logic Conference 2022 (FLoC 22 -- https://www.floc2022.org/) as a satellite workshop of the 34th International Conference on Computer-Aided Verification (CAV 2022 -- http://i-cav.org/2022/) ----------------------------------------------------------------- Important dates --------------------- Abstract submission: May 3, 2022, *May 10, 2022* Full paper submission: May 10, 2022 *May 17, 2022* Notification: June 15, 2022 Camera-ready: July 13, 2022 Workshop: August 11, 2022 Deadlines are Anywhere on Earth -- https://en.wikipedia.org/wiki/Anywhere_on_Earth. ---------------------- ---------------------- TOPICS OF INTEREST --------------------- Blockchains are decentralized transactional ledgers that rely on cryptographic hash functions for guaranteeing the integrity of the stored data. Participants on the network reach agreement on what valid transactions are through consensus algorithms. Blockchains may also provide support for Smart Contracts. Smart Contracts are scripts of an ad-hoc programming language that are stored in the Blockchain and that run on the network. They can interact with the ledger’s data and update its state. These scripts can express the logic of possibly complex contracts between users of the Blockchain. Thus, Smart Contracts can facilitate the economic activity of Blockchain participants. With the emergence and increasing popularity of cryptocurrencies such as Bitcoin and Ethereum, it is now of utmost importance to have strong guarantees of the behavior of Blockchain software. These guarantees can be brought by using Formal Methods. Indeed, Blockchain software encompasses many topics of computer science where using Formal Methods techniques and tools are relevant: consensus algorithms to ensure the liveness and the security of the data on the chain, programming languages specifically designed to write Smart Contracts, cryptographic protocols, such as zero-knowledge proofs, used to ensure privacy, etc. This workshop is a forum to identify theoretical and practical approaches of formal methods for Blockchain technology. Topics include, but are not limited to: * Formal models of Blockchain applications or concepts * Formal methods for consensus protocols * Formal methods for Blockchain-specific cryptographic primitives or protocols * Design and implementation of Smart Contract languages * Verification of Smart Contracts ---------------------- ---------------------- SUBMISSION --------------------- Submit original manuscripts (not published or considered elsewhere) with a page limit of 12 pages for full papers and Systemization of Knowledge (SoK) papers, and 6 pages for short papers, and 2 pages for tool papers (excluding bibliography and short appendix of up to 5 additional pages). Alternatively you may also submit an extended abstract of up to 3 pages (including bibliography) summarizing your ongoing work in the area of formal methods and blockchain. Authors of selected extended abstracts are invited to give a short lightning talk. Submission link: https://easychair.org/conferences/?conf=fmbc2022 Authors are encouraged to use LaTeX and prepare their submissions according to the instructions and styling guides for OASIcs provided by Dagstuhl. Instructions for authors: https://submission.dagstuhl.de/series/details/5#author At least one author of an accepted paper is expected to present the paper at the workshop as a registered participant. -------------------- -------------------- PROCEEDINGS ------------------- All submissions will be peer-reviewed by at least three members of the program committee for quality and relevance. Accepted regular papers (full and short papers) will be included in the workshop proceedings. ---------------------- ---------------------- INVITED SPEAKER --------------------- Massimo Bartoletti, Professor, Università degli Studi di Cagliari, Italy ---------------------- ---------------------- PROGRAM COMMITTEE --------------------- PC CO-CHAIRS * Zaynah Dargaye (Nomadic Labs, France) (zaynah.dargaye(a)nomadic-labs.com) * Clara Schneidewind (MPI-SP, Germany) (clara.schneidewind(a)mpi-sp.org) PC MEMBERS Wolfgang Ahrendt (Chalmers University of Technology, Sweden) Leonardo Alt (Ethereum Foundation, Germany) Lacramioara Astefanoaei (Nomadic Labs, France) Roberto Blanco (MPI-SP, Germany) Joachim Breitner (Germany) Achim Brucker (University of Exeter, UK) Ethan Cecchetti (University of Maryland, USA) Manuel Chakravarty (IOHK & Tweag, Netherlands) Jing Chen (Algorand Inc, USA) Jérémie Decouchant (TU Delft, Netherlands) Antonella Del Pozzo (Université Paris-Saclay & CEA & List, France) Dana Drachsler Cohen (Technion, Israel) Cezara Dragoi (INRIA & ENS & CNRS & PSL, France) Ansgar Fehnker (Twente, Netherlands) Dominik Harz (Interlay & Imperial College London, UK) Lars Hupel (INNOQ, Germany) Igor Konnov (Informal Systems, Austria) Paul Laforgue (Nomadic Labs, France) Julian Nagele (Bank of America, USA) Russel O’Connor (Blockstream) Maria Potop-Butucaru (LIP6, France) Albert Rubio (Complutense University of Madrid, Spain) César Sanchez (IMDEA, Spain) Sun Meng (Peking University, China) Simon Thompson (IO Global, UK) Josef Widder (Informal Systems, Austria)

1 0

Journal of Functional Programming - Call For PhD Abstracts
by Graham Hutton 03 May '22

03 May '22

Dear all, If you or one of your students recently completed a PhD in the area of functional programming, please submit the dissertation abstract for publication in JFP: simple process, no refereeing, open access, 200+ published to date, deadline 31st May 2022. Please share! Best wishes, Graham Hutton ============================================================ CALL FOR PHD ABSTRACTS Journal of Functional Programming Deadline: 31st May 2022 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 31st May 2022. 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

GHC 9.4.1-alpha1 now available
by Ben Gamari 02 May '22

02 May '22

The GHC developers are happy to announce the availability of the first alpha release of the GHC 9.4 series. Binary distributions, source distributions, and documentation are available at downloads.haskell.org: https://downloads.haskell.org/ghc/9.4.1-alpha1 This major release will include: - A new profiling mode, `-fprof-late`, which adds automatic cost-center annotations to all top-level functions *after* Core optimisation has run. This incurs significantly less performance cost while still providing informative profiles. - A variety of plugin improvements including the introduction of a new plugin type, *defaulting plugins*, and the ability for typechecking plugins to rewrite type-families. - An improved constructed product result analysis, allowing unboxing of nested structures, and a new boxity analysis, leading to less reboxing. - Introduction of a tag-check elision optimisation, bringing significant performance improvements in strict programs. - Generalisation of a variety of primitive types to be levity polymorphic. Consequently, the `ArrayArray#` type can at long last be retired, replaced by standard `Array#`. - Introduction of the `\cases` syntax from [GHC proposal 0302] - A complete overhaul of GHC's Windows support. This includes a migration to a fully Clang-based C toolchain, a deep refactoring of the linker, and many fixes in WinIO. - Support for multiple home packages, significantly improving support in IDEs and other tools for multi-package projects. - A refactoring of GHC's error message infrastructure, allowing GHC to provide diagnostic information to downstream consumers as structured data, greatly easing IDE support. - Significant compile-time improvements to runtime and memory consumption. - ... and much more We would like to thank Microsoft Azure, GitHub, IOHK, the Zw3rk stake pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket] if you see anything amiss. Happy testing, - Ben [GHC proposal 0302]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0302-c… [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

1 0

SPLASH 2022 Final Call for Workshop Proposals
by Andreea Costea 29 Apr '22

29 Apr '22

======================================================================== SPLASH 2022 Call for Workshops The ACM Conference on Systems, Programming, Languages, and Applications: Software for Humanity December 5-10, 2022, Auckland, New Zealand https://2022.splashcon.org/track/splash-2022-Workshops ======================================================================== We encourage proposals for workshops on any topic relevant to SPLASH. If there is a topic that you feel passionate about, and want to connect with others who have similar interests, submit a workshop proposal! We more than welcome new, and unconventional ideas for workshop formats. The following suggestions are a starting point: - Conference-style workshops allow participants to present their work to other domain experts. The smaller and more focused setting of a workshop allows for Q&A sessions and facilitates discussions. Presentations of work-in-progress are welcome. - Retreats act as a platform for experts to gather to tackle issues of a predetermined research agenda. Retreats are highly interactive and goal-oriented, allowing participants to address open challenges, explore new and uncharted ideas. - Agenda-setting workshops provide a forum for experts to determine a research agenda for a sub-field. - Other common activities at workshops include poster sessions, hands-on practical work, and focus groups. Workshops that include the presentation of research papers and that implement a SIGPLAN-approved selection process may archive proceedings in the ACM Digital Library. The workshop chairs will provide advice on achieving this for those interested. Workshop applications will be considered until **May 01, 2022**, or until all slots are allocated. We will also entertain requests for workshops to be held in remote or hybrid modes. ## Workshop Proposal Submission Visit the submission link for the workshop proposal form and for more information on requirements and the evaluation process. To submit a workshop proposal, you will need to login to http://conf.research.org. ## Important Deadlines - The deadline for proposal submission for all workshops is **May 01, 2022** - The deadline for paper/abstract submission for all workshops is **September 01, 2022** - The early registration deadline for SPLASH is **TBD**. Before the SPLASH early registration deadline, all workshops must a) send out accept/reject notifications, and b) publish a draft schedule on the SPLASH website. For workshops with proceedings published in the ACM Digital Library, **TBD** is the camera-ready deadline. Therefore, you should plan to notify authors several days before this date, so that they have time for revisions. **TBD** dates will be announced as soon as the SPLASH dates they are dependent on are decided. ## Questions Please [email the workshop co-chairs](mailto:workshops@splashcon.org) with any questions. ## Submission Link https://bit.ly/splash2022w ## Organizing Committee - Mehdi Bagherzadeh, Oakland University, USA - Raffi Khatchadourian, CUNY Hunter College, USA

1 0

Problem with ghc-9.2.2 on Windows
by Ben Franksen 28 Apr '22

28 Apr '22

Hi everyone I have a strange problem with ghc-9.2.2 on Windows. I recently updated the cabal file for darcs to allow building with ghc-9.2, which required only a few minor changes. But when I ran the tests using our github CI I noticed two regressions vs. ghc-9.0.2 on Windows. It turned out that both tests (shell scripts) try to run the darcs executable under test with a restricted PATH environment variable; the idea is to test what happens if darcs tries to run some external program which cannot be found in the PATH. The problem is that executing darcs under these circumstances fails immediately without any error message. In fact it seems to fail *before the main procedure is executed*. I tested this by printing some text to stderr in main before doing anything else and the text is not printed. The error cannot be reproduced with a simple example program, which seems to indicate that the problem may be caused by a library. But I am not aware of any way a library can influence code that is executed before main. Any kind of input on how to diagnose this problem further would be appreciated. I this were on Linux I'd use strace to find out if anything is trying to run an external program before main but this happens on Windows only and the only access I have to a Windows machine to run tests on is via the github CI. BTW, using `cabal freeze` I found these differences in library versions between the ghc-9.0 and ghc-9.2 builds. If I am not mistaken they are all "boot" libraries i.e. ones that come with ghc. ben@home[1]:.../darcs/screened>diff cabal.project.freeze-ghc-9.0 cabal.project.freeze-ghc-9.2 2c2 < constraints: any.Cabal ==3.4.1.0, --- > constraints: any.Cabal ==3.6.3.0, 25c25 < any.base ==4.15.1.0, --- > any.base ==4.16.1.0, 34c34 < any.binary ==0.8.8.0, --- > any.binary ==0.8.9.0, 37c37 < any.bytestring ==0.10.12.1, --- > any.bytestring ==0.11.3.0, 51c51 < any.containers ==0.6.4.1, --- > any.containers ==0.6.5.1, 61c61 < any.deepseq ==1.4.5.0, --- > any.deepseq ==1.4.6.1, 73c73 < any.filepath ==1.4.2.1, --- > any.filepath ==1.4.2.2, 76,78c76,78 < any.ghc-bignum ==1.1, < any.ghc-boot-th ==9.0.2, < any.ghc-prim ==0.7.0, --- > any.ghc-bignum ==1.2, > any.ghc-boot-th ==9.2.2, > any.ghc-prim ==0.8.0, 81a82 > haskeline +examples +terminfo, 113c114 < any.parsec ==3.1.14.0, --- > any.parsec ==3.1.15.0, 137c138 < any.stm ==2.5.0.0, --- > any.stm ==2.5.0.2, 148c149 < any.template-haskell ==2.17.0.0, --- > any.template-haskell ==2.18.0.0, 163c164 < any.time ==1.9.3, --- > any.time ==1.9.3 || ==1.11.1.1, Cheers Ben -- I would rather have questions that cannot be answered, than answers that cannot be questioned. -- Richard Feynman

2 2

Second CfP: FMBC 2022 - 4th International Workshop on Formal Methods for Blockchains
by Zaynah Dargaye 27 Apr '22

27 Apr '22

FMBC 2022 Second Call for Papers [ Please distribute, apologies for multiple postings. ] ======================================================================== 4th International Workshop on Formal Methods for Blockchains (FMBC) - First Call https://fmbc.gitlab.io/2022 August 11, 2022, Haifa, Israel Co-located with the The Federated Logic Conference 2022 (FLoC 22 -- https://www.floc2022.org/) as a satellite workshop of the 34th International Conference on Computer-Aided Verification (CAV 2022 -- http://i-cav.org/2022/) ----------------------------------------------------------------- Important dates --------------------- Abstract submission: May 3, 2022 Full paper submission: May 10, 2022 Notification: June 15, 2022 Camera-ready: July 13, 2022 Workshop: August 11, 2022 Deadlines are Anywhere on Earth -- https://en.wikipedia.org/wiki/Anywhere_on_Earth. ---------------------- ---------------------- TOPICS OF INTEREST --------------------- Blockchains are decentralized transactional ledgers that rely on cryptographic hash functions for guaranteeing the integrity of the stored data. Participants on the network reach agreement on what valid transactions are through consensus algorithms. Blockchains may also provide support for Smart Contracts. Smart Contracts are scripts of an ad-hoc programming language that are stored in the Blockchain and that run on the network. They can interact with the ledger’s data and update its state. These scripts can express the logic of possibly complex contracts between users of the Blockchain. Thus, Smart Contracts can facilitate the economic activity of Blockchain participants. With the emergence and increasing popularity of cryptocurrencies such as Bitcoin and Ethereum, it is now of utmost importance to have strong guarantees of the behavior of Blockchain software. These guarantees can be brought by using Formal Methods. Indeed, Blockchain software encompasses many topics of computer science where using Formal Methods techniques and tools are relevant: consensus algorithms to ensure the liveness and the security of the data on the chain, programming languages specifically designed to write Smart Contracts, cryptographic protocols, such as zero-knowledge proofs, used to ensure privacy, etc. This workshop is a forum to identify theoretical and practical approaches of formal methods for Blockchain technology. Topics include, but are not limited to: * Formal models of Blockchain applications or concepts * Formal methods for consensus protocols * Formal methods for Blockchain-specific cryptographic primitives or protocols * Design and implementation of Smart Contract languages * Verification of Smart Contracts ---------------------- ---------------------- SUBMISSION --------------------- Submit original manuscripts (not published or considered elsewhere) with a page limit of 12 pages for full papers and Systematization of Knowledge (SoK) papers, 6 pages for short papers, and 2 pages for tool papers (excluding bibliography and short appendix of up to 5 additional pages). Alternatively, you may also submit an extended abstract of up to 3 pages (including a bibliography) summarizing your ongoing work in the area of formal methods and blockchain. Authors of selected extended abstracts are invited to give a short lightning talk. -------------------- -------------------- PROCEEDINGS ------------------- All submissions will be peer-reviewed by at least three members of the program committee for quality and relevance. Accepted regular papers (full and short papers) will be included in the workshop proceedings. , published as a volume of the OpenAccess Series in Informatics (OASIcs <https://www.dagstuhl.de/en/publications/oasics/>) by Dagstuhl. ---------------------- ---------------------- INVITED SPEAKER --------------------- Massimo Bartoletti, Professor, Università degli Studi di Cagliari, Italy ---------------------- ---------------------- PROGRAM COMMITTEE --------------------- PC CO-CHAIRS * Zaynah Dargaye (Nomadic Labs, France) (zaynah.dargaye(a)nomadic-labs.com) * Clara Schneidewind, (MPI-SP, Germany) (clara.schneidewind(a)mpi-sp.org) PC MEMBERS Wolfgang Ahrendt (Chalmers University of Technology, Sweden) Leonardo Alt (Ethereum Foundation, Germany) Lacramioara Astefanoaei (Nomadic Labs, France) Roberto Blanco (MPI-SP, Germany) Joachim Breitner (Germany) Achim Brucker (University of Exeter, UK) Ethan Cecchetti (University of Maryland, USA) Manuel Chakravarty (IOHK & Tweag, Netherlands) Jing Chen (Algorand Inc, USA) Jérémie Decouchant (TU Delft, Netherlands) Antonella Del Pozzo (Université Paris-Saclay & CEA & List, France) Dana Drachsler Cohen (Technion, Israel) Cezara Dragoi (INRIA & ENS & CNRS & PSL, France) Ansgar Fehnker (Twente, Netherlands) Dominik Harz (Interlay & Imperial College London, UK) Lars Hupel (INNOQ, Germany) Igor Konnov (Informal Systems, Austria) Paul Laforgue (Nomadic Labs, France) Julian Nagele (Bank of America, USA) Russel O’Connor (Blockstream) Maria Potop-Butucaru (LIP6, France) Albert Rubio (Complutense University of Madrid, Spain) César Sanchez (IMDEA, Spain) Sun Meng (Peking University, China) Simon Thompson (IO Global, UK) Josef Widder (Informal Systems, Austria)

1 0

Shutting down a Yesod/warp application
by Olaf Klinke 27 Apr '22

27 Apr '22

Dear Cafe, this topic has been discussed [1,2] a decade ago. What is the current state of affairs in this matter? It still seems to be addressed neither in yesod nor warp [*]. We have two use cases: (1) A shutdown route that allows admins to cleanly shut down the web application. (2) We want certain exceptions to terminate the application and have the surrounding monitoring (systemd, docker, ...) re-start the application. For (2) we are safe, I think, because the worker threads are forked from the main thread [3] calling warp, so propagating the exceptions up to the top bypasses warp and yesod's very comprehensive exception handlers. But any exception thrown while answering a request (such as (1)) is caught by default. Thanks Olaf [1] https://groups.google.com/g/yesodweb/c/VoenrabRUBQ [2] https://stackoverflow.com/questions/7881327/how-do-i-implement-a-shutdown-c… [3] https://mail.haskell.org/pipermail/haskell-cafe/2022-March/135132.html [*] Warp offers setOnException and setOnExceptionResponse. But does re- throwing certain exceptions from there terminate warp?

2 1

Position of Lecturer or Senior Lecturer in Cybersecurity at University of Sheffield
by Andrei Popescu 26 Apr '22

26 Apr '22

Greetings, The Department of Computer Science at University of Sheffield has an open position of Lecturer or Senior Lecturer in Cybersecurity. Details can be found here: https://www.jobs.ac.uk/job/COY785/lecturer-senior-lecturer-in-cybersecurity Note that "formalisation and proof of system security properties" is listed as a topic of interest. Women are particularly encouraged to apply. All applicants will be given equal consideration. Best wishes, Andrei

1 0

Munich Haskell Meeting, 2022-04-28 @ 19:30
by Leah Neukirchen 26 Apr '22

26 Apr '22

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Thursday, April 28 at Augustiner-Gaststätte Rumpler at 19:30 CEST. 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-apr-2022/ Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

Near Semi Ring problem
by Henry Laxen 23 Apr '22

23 Apr '22

Dear Group, Many years ago I read a fascinating article which I can't seem to find anymore. It was about writing down (in english) the numbers from one to a billion? and being able to retrieve the nth letter. ie: onetwothreefourfive...ninehundredninetymillion....ninetynineonebillion I remember it used near semi rings and automatic differentiation, but no matter how I use those words to search (both google and duckduck) I can't find it. Do any of you have a pointer. I believe the code was written in haskell too. Best wishes, Henry Laxen

2 1

Haskell.org outage
by Ben Gamari 18 Apr '22

18 Apr '22

Hello everyone, Unfortunately Haskell.org, downloads.haskell.org, and hoogle.haskell.org are currently down. We are currently investigating the cause. Updates will be posted as they are available. Cheers, - Ben

1 1

Ord/Ix and Bounded?
by Zemyla 17 Apr '22

17 Apr '22

Are there any laws relating Bounded to Ord and Ix? For instance, any reasonable type should say minBound <= x == True for all x maxBound >= x == True for all x inRange (minBound, maxBound) x == True for all x

2 2