- Haskell-Cafe - Haskell.org

[ANNOUNCE] GHC 9.8.1-alpha3 is now available
by Ben Gamari 24 Aug '23

24 Aug '23

The GHC developers are very pleased to announce the availability of the third alpha prerelease of GHC 9.8.1. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.8.1-alpha3 GHC 9.8 will bring a number of new features and improvements, including: * Preliminary support the `TypeAbstractions` language extension, allowing types to be bound in type declarations [TypeAbstractions]. * Support for the `ExtendedLiterals` extension, providing syntax for non-word-sized numeric literals in the surface language [extended-literals] * Improved rewrite rule matching behavior, allowing limited matching of higher-order patterns * Better support for user-defined warnings by way of the `WARNING` pragma [warnings] * The introduction of the new `GHC.TypeError.Unsatisfiable` constraint, allowing more predictable user-defined type errors [unsatisfiable] * Implementation of the export deprecation proposal, allowing module exports to be marked with `DEPRECATE` pragmas [deprecated-exports] * The addition of build semaphore support for parallel compilation; with coming support in `cabal-install` this will allow better use of parallelism in multi-package builds [jsem] * More efficient representation of info table provenance information, reducing binary sizes by over 50% in some cases when `-finfo-table-map` is in use A full accounting of changes can be found in the [release notes]. This alpha includes roughly a dozen changes relative to alpha 2, including what we believe should be nearly the last changes to GHC's boot libraries. We would like to thank GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, the Haskell Foundation, 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, ~ Ben [TypeAbstractions]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0425-d… [extended-literals]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0451-s… [unsatisfiable]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0433-u… [warnings]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0541-w… [deprecated-exports]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0134-d… [jsem]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0540-j… [release notes]: https://downloads.haskell.org/ghc/9.8.1-alpha3/docs/users_guide/9.8.1-notes…

1 0

[ANNOUNCE] GHC 9.8.1-alpha2 is now available
by Ben Gamari 23 Aug '23

23 Aug '23

The GHC developers are very pleased to announce the availability of the second alpha prerelease of GHC 9.8.1. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.8.1-alpha2 GHC 9.8 will bring a number of new features and improvements, including: * Preliminary support the `TypeApplications` language extension [type-binders], allowing types to be bound in type declarations. * Support for the `ExtendedLiterals` extension, providing syntax for non-word-sized numeric literals in the surface language [extended-literals] * Improved rewrite rule matching behavior, allowing limited matching of higher-order patterns * Better support for user-defined warnings by way of the `WARNING` pragma [warnings] * The introduction of the new `GHC.TypeError.Unsatisfiable` constraint, allowing more predictable user-defined type errors [unsatisfiable] * Implementation of the export deprecation proposal, allowing module exports to be marked with `DEPRECATE` pragmas [deprecated-exports] * The addition of build semaphore support for parallel compilation; with coming support in `cabal-install` this will allow better use of parallelism in multi-package builds [jsem] * More efficient representation of info table provenance information, reducing binary sizes by over 50% in some cases when `-finfo-table-map` is in use A full accounting of changes can be found in the [release notes]. This alpha includes around two dozen bug-fixes relative to alpha 1. We would like to thank GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, the Haskell Foundation, 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, ~ Ben [type-binders]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0425-d… [extended-literals]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0451-s… [unsatisfiable]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0433-u… [warnings]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0541-w… [deprecated-exports]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0134-d… [jsem]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0540-j… [release notes]: https://downloads.haskell.org/ghc/9.8.1-alpha2/docs/users_guide/9.8.1-notes… [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

4 4

Re: [Haskell-cafe] Can I get 'forall (a :: k). Typeable a => Dict (Typeable k)'?
by Ryan Scott 23 Aug '23

23 Aug '23

To respond to your original point: > Morally I think that > > class Typeable (a :: k) > > should have been > > class Typeable k => Typeable (a :: k) > > This has been considered before, although it is not entirely straightforward to implement. See [1] and [2], which track the idea of having GHC solve these constraints automatically, without the need for users to explicitly reach for `typeRepKind`. Best, Ryan ----- [1] https://gitlab.haskell.org/ghc/ghc/-/issues/14190 [2] https://gitlab.haskell.org/ghc/ghc/-/issues/16627

2 1

Can I get 'forall (a :: k). Typeable a => Dict (Typeable k)'?
by Tom Ellis 23 Aug '23

23 Aug '23

Morally I think that class Typeable (a :: k) should have been class Typeable k => Typeable (a :: k) If I'm wrong, could someone please elaborate why? If I'm right, please read on ... That would be a breaking change, but could we at least get kindable :: forall (a :: k). Typeable a => Dict (Typable (a :: k)) in the meantime? Tom

3 6

[ANN] avif - libavif bindings on Hackage
by Vanessa McHale 13 Aug '23

13 Aug '23

Hello all, I have release avif, a Haskell wrapper around libavif compatible with JuicyPixels. https://hackage.haskell.org/package/avif Cheers, Vanessa McHale

1 0

[ANNOUNCE] mig - new library to write composable web-servers
by Anton Kholomiov 09 Aug '23

09 Aug '23

I'm happy to announce the release of a new library for web-servers. It offers simple and concise functions to build servers from small parts. Servers are monoids, and we can aggregate them with functions like `mconcat`. Main features: * lightweight library * expressive DSL to compose servers * type-safe handlers * handlers are encoded with generic haskell functions * built on top of WAI and warp server libraries. For DSL design I wanted to touch the middle ground between scotty (being small and simple, but imperative) and servant (being composable, but somewhat advanced on type-level features) I like scotty for being very simple and servant for being composable, type-safe and how functions are used as handlers which provides decoupling of Web-handlers from application logic. But sometimes scotty feels too imperative and lacks a servant's composability. And servant with type-level magic and huge errors can feel too complicated. So I wanted to create something in the middle. Something composable and simple at the same time. And be able to use arbitrary haskell functions as handlers. There are only two functions to combine servers. And types of inputs and outputs are encoded with newtype-wrpappers with phantom types which provide type-safety. It's very first release. So feedback is welcome and I'm sure there are places to improve. I hope that you will enjoy the lib. links: * [github](https://github.com/anton-k/mig) * [hackage](https://hackage.haskell.org/package/mig-0.1.0.1) * [examples]( https://github.com/anton-k/mig/tree/main/examples/mig-example-apps) * [example of a handle pattern app]( https://github.com/anton-k/handle-pattern-mig-app) * [example of a reader pattern app]( https://github.com/anton-k/reader-pattern-mig-app) Cheers, Anton

2 1

[Call for submissions TFPiE 2024] Trends in Functional Programming in Education - January 9 2024, Seton Hall University, USA
by Peter Achten 08 Aug '23

08 Aug '23

TFPIE 2024 Call for papers https://wiki.tfpie.science.ru.nl/TFPIE2024 (January 9th 2024, West Orange, NJ, USA, co-located with TFP 2024 at Seton Hall University) TFPIE 2024 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: FP and beginning CS students FP and Computational Thinking FP and Artificial Intelligence FP in Robotics FP and Music Advanced FP for undergraduates FP in graduate education Engaging students in research using FP FP in Programming Languages FP in the high school curriculum FP as a stepping stone to other CS topics FP and Philosophy The pedagogy of teaching FP FP and e-learning: MOOCs, automated assessment etc. Best Lectures - more details below In addition to papers, we are requesting best lecture presentations. What's your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. The length of the presentation should be comparable to that of a paper. In addition, the speaker can provide commentary on effectiveness or student feedback. Submissions Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 20 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website. Papers and abstracts can be submitted via easychair at the following link: https://easychair.org/conferences/?conf=tfpie2024 After the workshop, presenters are invited to submit (a revised version of) their article for the formal review. The PC will select the best articles for publication in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. Important Dates Submission deadline: December 26th 2023, Anywhere on Earth Notification: by December 30th 2023 (Note: submissions will be evaluated on a rolling basis, so earlier submissions will receive an earlier response) TFPIE Registration Deadline: TBA Workshop: January 9th 2024 Submission for formal review: April 19th 2024, Anywhere on Earth. Notification of full article: May 24th 2024 Camera ready: June 28th 2024 Program Committee - TBD Stephen Chang (Chair) - UMass Boston, USA Registration information See https://wiki.tfpie.science.ru.nl/TFPIE2024 for updated information. Registration and attendance are mandatory for at least one author of every paper that is presented at the workshop. Presenters will have their registration fee waived. Only papers that have been presented at TFPIE may be submitted to the post-reviewing process.

1 0

[ANN] Yampa 0.14.4
by Ivan Perez 08 Aug '23

08 Aug '23

Hi everyone, I'm very happy to announce the release of Yampa 0.14.4 and yampa-test 0.14.4. Yampa is a fast, elegant Functional Reactive Programming implementation. Yampa prides itself in being a long-standing community project. It has now been around for 20 years!!! See https://github.com/ivanperez-keera/yampa#features for details on Yampa's features. This release introduces a benchmark that can be used to evaluate the performance of a proposed change to Yampa, as well as to compare different ways of writing the same expressions. We hope that the benchmarks will improve and grow over time, and that they will help speed up the process of evaluating pull requests submitted to the project. Performance can be tricky to evaluate precisely, so no eyes are too many. We invite everyone to go to the Github repo and discuss ways to make the benchmarks more reliable, representative, and useful. This release also introduces version bounds for dependencies that did not have them, which will make Yampa easier to install. The current release has been tested with all major GHC versions from 7.6 to 9.6. Special thanks go to @johannes-riecken for a regular contribution to support the Yampa project. For details, see: - https://github.com/ivanperez-keera/Yampa/releases/tag/v0.14.4 The Yampa ecosystem comprises many projects. You can explore the current versions at: - https://hackage.haskell.org/package/Yampa - https://hackage.haskell.org/package/yampa-test - https://hackage.haskell.org/package/yampa-gloss - https://hackage.haskell.org/package/simple-affine-space - https://hackage.haskell.org/package/SpaceInvaders - https://hackage.haskell.org/package/haskanoid # Code The github repos are located at: - https://github.com/ivanperez-keera/Yampa/ - https://github.com/ivanperez-keera/yampa-gloss/ - https://github.com/ivanperez-keera/simple-affine-space/ - https://github.com/ivanperez-keera/SpaceInvaders/ - https://github.com/ivanperez-keera/haskanoid/ # What's coming This release comes exactly 2 months after the last release. The next release is planned for Oct 7, 2023. There are several issues open that you can contribute to. Following our roadmap, we plan to: - Create demos and examples using GHC's web backends. - Remove unnecessarily exposed elements from the interface (e.g., FRP.Yampa.Arrow.arr3) that are not used and belong in other libraries. This topic is open to discussion. - Switch from the old mailing list to a new discussion method. We will in the future lose access to Yale's CS department-based mailman list, and are thinking of the best place to move to. For now, the Discussions tab on Github has been enabled. # Other news I'm also happy to report that the paper "The Beauty and Elegance of Functional Reactive Animation" has been accepted for presentation at FARM 2023. The paper discusses different animations that can easily be created using Yampa. I invite you all to download the paper once it's published, and to stop by FARM 2023 if you are at ICFP next month! # Donations Our project is seeking donations to help continue developing Yampa, create new open source libraries, new material, and give talks. No donation is too small. Any contribution will absolutely help. See https://github.com/sponsors/ivanperez-keera for details. If you can help, please come forward. All the best, Ivan

1 0

Haskell GitLab abuse
by aeiouaeiouaeiouaeiouaeiouaeiou 03 Aug '23

03 Aug '23

Spam detection software, running on the system "mail.haskell.org", has identified this incoming email as possible spam. The original message has been attached to this so you can view it (if it isn't spam) or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: Hi everyone, I don't know where the best place to post about this issue is, so here goes. Recently I found that some Google results are bloated with malicious links from Haskell GitLab fork repositories. You can see for yourself: https://gitlab.haskell.org/search?repository_ref=master&scope=blobs&search=… [...] Content analysis details: (5.1 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- 3.0 SINGLE_HEADER_3K A single header contains 3K-4K characters 1.3 HK_RANDOM_FROM From username looks random 0.0 HK_RANDOM_ENVFROM Envelope sender username looks random -0.0 SPF_HELO_PASS SPF: HELO matches SPF record -0.0 T_RP_MATCHES_RCVD Envelope sender domain matches handover relay domain -0.0 SPF_PASS SPF: sender matches SPF record 0.8 BAYES_50 BODY: Bayes spam probability is 40 to 60% [score: 0.5000] 0.0 T_DKIM_INVALID DKIM-Signature header exists but is not valid The original message was not completely plain text, and may be unsafe to open with some email clients; in particular, it may contain a virus, or confirm that your address can receive spam. If you wish to view it, it may be safer to save it to a file and open it with an editor.

3 2

ICFP 2023: Call for Participation
by ICFP Publicity 03 Aug '23

03 Aug '23

===================================================================== Call for Participation The 28th ACM SIGPLAN International Conference on Functional Programming (ICFP 2023) and affiliated events https://icfp23.sigplan.org Seattle, USA; Sep 4-9, 2023 ===================================================================== ICFP is a celebration of the art and science of functional programming, providing a forum for researchers and developers to engage on a variety of topics, from foundations to features, and from abstraction to application. You are invited to participate in a full week dedicated to functional programming, featuring the ICFP main conference as well as several other related events. * Accepted Papers: https://icfp23.sigplan.org/track/icfp-2023-papers#event-overview * Registration: https://icfp23.sigplan.org/attending/registration The early-bird deadline is August 5, 2023 * Hotel: The Westin Seattle https://icfp23.sigplan.org/venue/icfp-2023-venue Conference hotel reservation cutoff: August 11, 2023 There are several events affiliated with ICFP: September 4 Erlang - https://icfp23.sigplan.org/home/erlang-2023 FHPN - https://icfp23.sigplan.org/home/FHPNC-2023 HIW - https://icfp23.sigplan.org/home/hiw-2023 HOPE - https://icfp23.sigplan.org/home/hope-2023 PLMW - https://icfp23.sigplan.org/track/plmw-icfp-2023 TyDe - https://icfp23.sigplan.org/home/TyDe-2023 September 5-7 ICFP - Main conference September 8 Haskell - https://icfp23.sigplan.org/home/haskellsymp-2023 FARM - https://icfp23.sigplan.org/home/farm-2023 FUNARCH - https://icfp23.sigplan.org/home/FUNARCH-2023 ML - https://icfp23.sigplan.org/home/mlworkshop-2023 miniKanren - https://icfp23.sigplan.org/home/minikanren-2023 Tutorial: Vehicle, A Specification Language for Neural Network Properties Tutorial: Porting Lwt applications to OCaml 5 and Eio September 9 Haskell - https://icfp23.sigplan.org/home/haskellsymp-2023 Scheme - https://icfp23.sigplan.org/home/scheme-2023 OCaml - https://icfp23.sigplan.org/home/ocaml-2023 DeclMed - https://icfp23.sigplan.org/home/declmed-2023 Tutorial: Teaching and Learning Compilers Incrementally Tutorial: Teaching functional programming Conference organizers: https://icfp23.sigplan.org/committee/icfp-2023-organizing-committee =====================================================================

1 0

Call for Lightning Talks: Haskell Implementors' Workshop 2023
by Ryan Scott 02 Aug '23

02 Aug '23

ACM SIGPLAN Haskell Implementors' Workshop https://icfp23.sigplan.org/home/hiw-2023 Seattle, Washington, United States, September 4, 2023 Co-located with ICFP 2023 https://icfp23.sigplan.org/ --------------- The 15th Haskell Implementors' Workshop is to be held alongside ICFP 2023 this year in Seattle. It is a forum for people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure to share their work and to discuss future directions and collaborations with others. We have a number of slots for lightning talks. Lightning talks will be ~7 minutes and are scheduled on the day of the workshop. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. Lightning talks are proposed by submitting a title and an abstract. Submissions will not be part of the peer-review process. Notification of acceptance will be continuous until slots are full. Accepted lightning talks will be posted on the workshop’s website. Submissions should be made via this Google form: https://forms.gle/2jGceompwNghbRQR9 Accepted lightning talks will be posted on the workshop’s website. Scope and target audience ------------------------- The Implementors' Workshop is an ideal place to describe a Haskell extension, describe works-in-progress, demo a new Haskell-related tool, or even propose future lines of Haskell development. Members of the wider Haskell community are encouraged to attend the workshop -- we need your feedback to keep the Haskell ecosystem thriving. Students working with Haskell are especially encouraged to share their work. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimisation and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment Contact ------- * Ryan Scott <ryan.gl.scott at gmail.com>

1 0

IFL23 - Deadline extension - Symposium on Implementation and Application of Functional Languages
by Pieter Koopman 31 Jul '23

31 Jul '23

Dear all, on special request, the deadline for draft paper submissions is extended until *August 7th*, 2023. *Scope* The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2022 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: * language concepts * type systems, type checking, type inferencing * compilation techniques * staged compilation * run-time function specialization * run-time code generation * partial evaluation * abstract interpretation * metaprogramming * generic programming * automatic program generation * array processing * concurrent/parallel programming * concurrent/parallel program execution * embedded systems * web applications * embedded domain specific languages * security * novel memory management techniques * run-time profiling performance measurements * debugging and tracing * virtual/abstract machine architectures * validation, verification of functional programs * tools and programming techniques * industrial applications *Submissions and peer-review* Following IFL tradition, IFL 2023 will use a post-symposium review process to produce the formal proceedings. Before the symposium authors submit draft papers. These draft papers will be screened by the program chair to make sure that they are within the scope of IFL. The draft papers will be made available to all participants at the symposium. Each draft paper is presented by one of the authors at the symposium. Notice that it is a requirement that accepted draft papers are presented physically at the symposium. After the symposium, a formal review process will take place, conducted by the program committee. Reviewing is single blind. There will be at least 3 reviews per paper. The reviewers have 6 weeks to write their reviews. For the camera-ready version the authors can make minor revisions which are accepted without further reviewing. Contributions submitted for the draft paper deadline must be between two and twelve pages long. For submission details, please consult the IFL 2023 website at https://ifl23.github.io/ <https://ifl21-publicity-dot-yamm-track.appspot.com/2BAsSNEGa7Qjzm9dLvMbB3Fu…> . *Where* IFL 2023 will be held physically in Braga, Portugal, arranged by University of Minho. See the IFL 2023 website at https://ifl23.github.io/ <https://ifl21-publicity-dot-yamm-track.appspot.com/202BkMEM4iDsNER-G6iYruAX…> for more information. [image: beacon]

1 0

developing using .devcontainer in vscode
by Han Joosten 31 Jul '23

31 Jul '23

Hi Cafe, I am trying to set up a useful development container for an open source project I am working on. I have created an image on top of the official Haskell image, expecting a proper installation of ghcup, cabal, stack and hls. The Dockerfile looks like this: FROM haskell:8.10 ARG USERNAME=vscode ENV USERNAME=${USERNAME} \ USER_UID=1000 \ USER_GID=1000 \ DEBIAN_FRONTEND=noninteractive \ LANG=C.UTF8 \ WDIR=/home/${USERNAME} RUN apt-get update && \ apt-get upgrade -y && \ apt-get install -y git RUN groupadd --gid $USER_GID $USERNAME && \ useradd -ms /bin/bash -K MAIL_DIR=/dev/null --uid $USER_UID --gid $USER_GID -m $USERNAME && \ mkdir -p /etc/sudoers.d && \ echo $USERNAME ALL=$root$ NOPASSWD:ALL > /etc/sudoers.d/$USERNAME && \ chmod 0440 /etc/sudoers.d/$USERNAME USER ${USER_UID}:${USER_GID} WORKDIR ${WDIR} RUN stack update # Add just the .cabal file to capture dependencies COPY ./package.yaml ${WDIR}/package.yaml COPY ./stack.yaml ${WDIR}/stack.yaml # Docker will cache this command as a layer, freeing us up to # modify source code without re-installing dependencies # (unless one of the copied files changes!) RUN stack build --only-dependencies -j4 COPY . ${WDIR} ENV DEBIAN_FRONTEND=dialog ENTRYPOINT ["/bin/bash"] The above image is built and pushed to dockerhub. Then, in the vscode project, I have a .devcontainer directory with the following Dockerfile: FROM ampersandtarski/ampersand-devcontainer:latest ENV DEBIAN_FRONTEND=dialog ENTRYPOINT ["/bin/bash"] The idea is that all the building of the dependencies is already done in the first image. That takes a lot of time, so this is supposed to be a great timesaver (though the image itself is huge). However, when I open the project inside the container, I get the following error: [image: image.png] If I reload the window, I get the following errors: [image: image.png] Long story short, I am not sure how to use the official Haskell image for development in my project. I must be missing something. I have been trying lots of things, but without succes. I hope it is possible to have an image built on top of the official Haskell file that contains all prebuilt dependencies of my project. Are my expectations realistic? If so, what am I missing? Any help is much appreciated.

2 1

[ANNOUNCE] GHC 9.8.1-alpha1 is now available
by Ben Gamari 28 Jul '23

28 Jul '23

The GHC developers are very pleased to announce the availability of the first alpha prerelease of GHC 9.8.1. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.8.1-alpha1 GHC 9.8 will bring a number of new features and improvements, including: * Preliminary support the `TypeApplications` language extension [type-binders], allowing types to be bound in type declarations. * Support for the `ExtendedLiterals` extension, providing syntax for non-word-sized numeric literals in the surface language [extended-literals] * Improved rewrite rule matching behavior, allowing limited matching of higher-order patterns * Better support for user-defined warnings by way of the `WARNING` pragma [warnings] * The introduction of the new `GHC.TypeError.Unsatisfiable` constraint, allowing more predictable user-defined type errors [unsatisfiable] * Implementation of the export deprecation proposal, allowing module exports to be marked with `DEPRECATE` pragmas [deprecated-exports] * The addition of build semaphore support for parallel compilation; with coming support in `cabal-install` this will allow better use of parallelism in multi-package builds [jsem] * More efficient representation of info table provenance information, reducing binary sizes by over 50% in some cases when `-finfo-table-map` is in use A full accounting of changes can be found in the [release notes]. We would like to thank GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, the Haskell Foundation, 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, ~ Ben [type-binders]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0425-d… [extended-literals]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0451-s… [unsatisfiable]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0433-u… [warnings]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0541-w… [deprecated-exports]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0134-d… [jsem]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0540-j… [release notes]: https://downloads.haskell.org/ghc/9.8.1-alpha1/docs/users_guide/9.8.1-notes… [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

1 0

IFL23 last Call for papers
by Pieter Koopman 28 Jul '23

28 Jul '23

Important Dates Draft Paper Submission Deadline 31st July, 2023 Notification of Acceptance for Presentation 1st August, 2023 Early Registration Deadline 11th August, 2023 Late Registration Deadline 23rd August, 2023 IFL Symposium 29th - 31st August, 2023 Submission of Papers for Peer-Reviewed Proceedings 24th November, 2023 Notification of Acceptance 2nd February, 2024 Camera-ready Version 8th March, 2024 SCOPE AND TOPICS The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. You can find more information about the symposium on its oficial website <https://ifl21-publicity-dot-yamm-track.appspot.com/29dDA6XwvedbWv4fOQOENw2-…>. IFL 2023 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. See the call for papers in text format <https://ifl21-publicity-dot-yamm-track.appspot.com/22-oQB0FEIVsa3YDKL7S2hh9…> . Areas of interest include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - abstract interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - embedded domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - industrial applications PAPER SUBMISSIONS Following IFL tradition, IFL 2023 will use a post-symposium review process to produce the formal proceedings. Before the symposium, authors submit draft papers. These draft papers will be screened by the program chair to make sure that they are within the scope of IFL. The draft papers will be made available to all participants at the symposium. Each draft paper is presented by one of the authors at the symposium. Notice that it is a requirement that accepted draft papers are presented physically at the symposium. After the symposium every presenter is invited to submit a full paper, incorporating feedback from discussions at the symposium. Work submitted to IFL may not be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected for the formal proceedings. As in previous years, we will try to have the papers that are accepted for the formal proceedings published in the International Conference Proceedings Series of the ACM Digital Library. This possibility will be confirmed as soon as possible. Reviewing is single blind. There will be at least 3 reviews per paper. For the camera-ready version the authors can make minor revisions which are accepted without further reviewing. Papers must use the ACM two columns conference format, which can be found here <https://ifl21-publicity-dot-yamm-track.appspot.com/2Z34AGflDaGf8EcFImELD02V…>. (For LaTeX users, start your document with \documentclass[sigconf,screen,review]{acmart}.) All contributions must be written in English. Note that this format has a rather long but limited list of packages that can be used. Please make sure that your document adheres to this list. The page limit for papers is twelve pages (excluding references). Only papers that were presented at the IFL 2023 Symposium will be considered for publication. See the webpage for paper submissions. LOCATION IFL 2023 will be held physically in Braga, Portugal. For more information, click here <https://ifl21-publicity-dot-yamm-track.appspot.com/2YpNKpbXPCivYXoXnLEVurcA…>. Registration information will be added as soon as possible. [image: beacon]

1 0

Call for Participation, Functional Software Architecture - FP in the Large
by Graham Hutton 26 Jul '23

26 Jul '23

====================================================================== *** FUNARCH 2023 -- CALL FOR PARTICIPATION *** The First ACM SIGPLAN Workshop on Functional Software Architecture - FP in the Large 8th September 2023, Seattle, Washington, USA Co-located with ICFP 2023 https://www.functional-architecture.org/events/funarch-2023/ ====================================================================== BACKGROUND: The ACM SIGPLAN Workshop on Functional Software Architecture - FP in the Large aims to disseminate and enable the use of functional programming in the large and long-lived software projects. We specifically want: - To assemble a community interested in software architecture techniques and technologies specific to functional programming; - To identify, categorize, and document topics relevant to the field of functional software architecture; - To connect the functional programming community to the software architecture community to cross-pollinate between the two. We'd love for you to be part of this effort. Whatever your background, you're welcome at FUNARCH - to listen to talks, report on your experience, and interact with others that share our goals. See you at FUNARCH! REGISTRATION: You can register for the workshop via the registration page for the ICFP conference, but there's no need to also register for the conference. Reduced fees are available until 5th August. http://icfp23.sigplan.org/attending/registration OPENING TALK: Functional Programming in the Large - Status and Perspective Mike Sperber ACCEPTED SUBMISSIONS: A Software Architecture Based on Coarse-Grained Self-Adjusting Computations Stefan Wehr Crème de la Crem: Composable Representable Executable Machines Marco Perone and Georgios Karachalias Functional Shell and Reusable Components for Easy GUIs Ben Knoble and Bogdan Popa Phases in Software Architecture Jeremy Gibbons, Oisín Kidney, Tom Schrijvers and Nicolas Wu Stretching the Glasgow Haskell Compiler Jeffrey M. Young, Sylvain Henry and John Ericson Typed Design Patterns for the Functional Era Will Crichton Types that Change: The Extensible Type Design Pattern Ivan Perez PROGRAM CHAIRS: Mike Sperber Active Group, Germany Graham Hutton University of Nottingham, UK PROGRAM COMMITTEE: Joachim Breitner Germany Manuel Chakravarty Tweag & IOG, The Netherlands Ron Garcia University of British Columbia, Canada Debasish Ghosh LeadIQ, India Lars Hupel Giesecke+Devrient, Germany Andy Keep Meta, USA Shriram Krishnamurthi Brown University, USA Andres Löh Well-Typed, Germany Anil Madhavapeddy University of Cambridge, UK José Pedro Magalhães Standard Chartered, UK Simon Marlow Meta, UK Hannes Mehnert Robur, Germany Erik Meijer USA Ivan Perez KBR / NASA Ames Research Center, USA Stefanie Schirmer DuckDuckGo, Germany Perdita Stevens University of Edinburgh, UK Stefan Wehr Hochschule Offenburg, Germany Scott Wlaschin FPbridge, UK WORKSHOP VENUE: The workshop will be co-located with the ICFP 2023 conference at The Westin Seattle Hotel, Seattle, Washington, United States. ====================================================================== 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

Munich Haskell Meeting, 2023-07-26 @ 19:30
by Leah Neukirchen 24 Jul '23

24 Jul '23

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Wednesday, July 26 at Cafe Puck at 19h30, as the weather will be wet and cold. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this nuudel so we can reserve enough seats! It is OK to add yourself to the nuudel anonymously or pseudonymously. https://nuudel.digitalcourage.de/QEVV6sKxTm2DGwle Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

Redundant/overlapping patterns?
by Todd Wilson 22 Jul '23

22 Jul '23

Hi, Cafe, Can someone please explain this: ghci> case 1 of 2 -> 3 <interactive>:1:11: warning: [-Woverlapping-patterns] Pattern match is redundant In a case alternative: 2 -> ... *** Exception: <interactive>:1:1-16: Non-exhaustive patterns in case The non-exhaustive patterns part is obvious, but what is redundant about this match? And how can there be overlapping patterns when there's only one? Todd Wilson

6 10

Citation information for 'base' hackage docs
by Patrick L Redmond 18 Jul '23

18 Jul '23

Hi Haskell-Cafe, I'd like to cite the documentation for a particular module and version of the "base" package in an academic publication. In this case, it makes sense to cite the documentation instead of the papers listed at the top because the behavior described in the documentation isn't described by the papers (the module's implementation has diverged from them). To what author should I attribute the documentation? The page lists " libraries(a)haskell.org" as the maintainer. What title should I give for the work? The html title is "Control.Exception". Thank you, Patrick

3 2

Taking over maintenance of int-cast package
by Nikolay Yakimov 17 Jul '23

17 Jul '23

I intend to take over int-cast (https://hackage.haskell.org/package/int-cast) package. I think it implements a reasonable approach to ensuring compile-time safety of integer casts, and it would be sad to see it silently fall into obscurity due to the lack of maintenance. This was discussed on GitHub (https://github.com/haskell-hvr/int-cast/issues/5#issuecomment-1620402453) since July 4, 2023, and I tried reaching @hvr via e-mail on July 5. Didn't receive a reply at the time of writing, and it seems unlikely I will anytime soon, hence moving on with the takeover process. This message is cross-posted to Haskell Discourse (https://discourse.haskell.org/t/taking-over-maintenance-of-int-cast-package…)

1 0

Re: [Haskell-cafe] Musings on lists
by Olaf Klinke 14 Jul '23

14 Jul '23

The fact that [a] is a linked list is exploited in Data.List.tails as well as in https://hackage.haskell.org/package/suffixtree where suffixes and internal segments of the tree all use Cons cells of the original list, so the overhead is only in the tree structure itself. In fact, exploiting the location of the internal tree nodes relative to the original list, one could compress the list similarly to the Lempel-Ziv 78 algorithm. This way, bioinformaticians manage to create full-text index structures [*] that are not much larger, or even smaller than, the original text. Olaf [*] Lempel-Ziv 78 creates a suffix tree of the text holding only a subset of all suffixes, namely those starting at a block boundary. This already suffices to find all occurrences of substrings spanning a block boundary.

1 0

Musings on lists
by Todd Wilson 13 Jul '23

13 Jul '23

Deaf Cafe, I'm an educator using Haskell, and I've been telling my students certain stories about Haskell evaluation that I'm now starting to question, so I'm writing for some clarification. I've written before about similar things (e.g., "Basic list exercise" from Mar 16), so it seems my own education on this topic is not yet complete! My apologies if this is too trivial for the Cafe. One story I tell students is that list concatenation, xs ++ ys, ends up "copying" the elements of xs but not the elements of ys, and in particular an expression like xs ++ [a], putting a new element at the end of a list, is particularly expensive, at least compared to x : xs, putting one at the beginning, which seems obvious, right? But here is my question: isn't xs ++ ys just a thunk that, as elements are "requested" from it, produces them first from xs and then, when those run out, defers entirely to ys from that point on? If so, then the elements of xs aren't "copied" any more than the elements of ys are; they are just produced from different places. Even the expression xs ++ [a] isn't problematic in this light: just act like xs, but with one more "card up the sleeve" when you are done. Have I gotten that right? Second, if the above is correct, then if there is a nesting, (xs ++ ys) ++ zs, and we want an element from it, there will be two steps before we can get that element from xs. And this will continue until xs is exhausted, at which point we get new elements in one step from ys, and finally in zero steps from zs. But ++ is associative, and so this list is also xs ++ (ys ++ zs), which requires less work getting the elements from xs. Is this kind of optimization something that is or can be done (automatically)? Thanks for your indulgence, Todd Wilson

6 7

Re: [Haskell-cafe] Musings on lists
by Olaf Klinke 13 Jul '23

13 Jul '23

Perhaps, if the students have been in contact with a language that has explicit pointers (C or C++), let them implement linked lists and concatenation in that procedural language. (An AI will likely also produce a correct implementation nowadays.) The advantage is that one can inspect the values of the pointers to see whether any copying has happened. Then the students easily see that only the spine (structure holding pointers) is re-created, but the memory the list elements point to is never touched. That is an instance of parametricity, I believe. The fact that length (replicate 3 undefined ++ replicate 2 undefined) evaluates to 5 also shows this. Olaf

2 1

[TFP 2024 Call for Papers] 25th International Symposium on Trends in Functional Programming
by Peter Achten 12 Jul '23

12 Jul '23

# TFP 2024 -- Call for Papers (trendsfp.github.io) ## Important Dates Submission deadline: pre-symposium, full papers, Saturday 4 November, 2023 Submission deadline: pre-symposium, draft papers, Wednesday 30 November, 2023 Notification: pre-symposium submissions, Friday 8 December, 2023 TFPIE Workshop: Tuesday 9 January, 2024 TFP Symposium: Wednesday 10 - Friday 12 January, 2024 Submission deadline: post-symposium review, Friday 23 February, 2024 Notification: post-symposium submissions, Friday 5 April, 2024 The Symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions. This year, TFP will take place in-person at Seton Hall University, in South Orange, NJ in the United States. It is co-located with the Trends in Functional Programming in Education (TFPIE) workshop, which will take on the day before the main symposium. Please be aware that TFP has several submission deadlines. The first, November 4, is for authors that wish to have their full paper reviewed prior to the symposium. Papers that are accepted in this way must also be presented at the symposium. The second, November 30, is for authors that wish to present their work or work-in progress at the symposium first without submitting to the full review process for publication. These authors can then take into account feedback received at the symposium and submit a full article for review by the third deadline, February 23. ## Scope The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: * Research Articles: Leading-edge, previously unpublished research work * Position Articles: On what new trends should or should not be * Project Articles: Descriptions of recently started new projects * Evaluation Articles: What lessons can be drawn from a finished project * Overview Articles: Summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: * Functional programming and multicore/manycore computing * Functional programming in the cloud * High performance functional computing * Extra-functional (behavioural) properties of functional programs * Dependently typed functional programming * Validation and verification of functional programs * Debugging and profiling for functional languages * Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. * Interoperability with imperative programming languages * Novel memory management techniques * Program analysis and transformation techniques * Empirical performance studies * Abstract/virtual machines and compilers for functional languages * (Embedded) domain specific languages * New implementation strategies * Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2024 program chair, Jason Hemann. ## Best Paper Awards TFP awards two prizes for the best papers each year. First, to reward excellent contributions, TFP awards a prize for the best overall paper accepted for the post-conference formal proceedings. Second, each year TFP also awards a prize for the best student paper. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are the paper’s first authors, and a student would present the paper. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, then that paper will receive both prizes. ## Instructions to Authors Authors must submit papers to: <https://easychair.org/conferences/?conf=tfp24> Authors of papers have the choice of having their contributions formally reviewed either before or after the Symposium. Further, pre-symposium submissions may either be full (earlier deadline) or draft papers (later deadline). ## Pre-symposium formal review Papers to be formally reviewed before the symposium should be submitted before the early deadline and will receive their reviews and notification of acceptance for both presentation and publication before the symposium. A paper that has been rejected for publication but accepted for presentation may be resubmitted for the post-symposium formal review. ## Post-symposium formal review Draft papers will receive minimal reviews and notification of acceptance for presentation at the symposium. Authors of draft papers will be invited to submit revised papers based on the feedback receive at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. ## Paper categories Draft papers and papers submitted for formal review are submitted as extended abstracts (4 to 10 pages in length) or full papers (20 pages). The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate which authors are research students, and whether the main author(s) are students. A draft paper for which all authors are students will receive additional feedback by one of the PC members shortly after the symposium has taken place. ## Format Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS Guidelines web site: <https://www.springer.com/gp/computer-science/lncs/conference-proceedings-gu…> ## Organizing Committee Jason Hemann PC Chair Seton Hall University, USA Stephen Chang Symposium Chair University of Massachusetts Boston, USA Shajina Anand Local Arrangements Seton Hall University, South Orange, USA

1 0

Re: [Haskell-cafe] Representing a type system in Haskell
by Olaf Klinke 11 Jul '23

11 Jul '23

> So this type system was designed such that I could: > Get a value of a type -> Convert it to lua types -> call lua code > with it -> Convert into my type system -> Type check the result I think you're describing a functor here, at least a commutative square. You're looking at a subset of Haskell, described by the types of your scripting language, whose functions can be mapped to another language (lua in your case). Personally, I would try to avoid defining, parsing and type-checking an entirely new language if there is a chance of embedding it into Haskell. Especially when it must be quite feature-rich as for writing games. Perhaps a quasi-quoter is sufficient? Also have a look at 'zoom' and 'focus' from the lens package. They let you write state transformers that care only about a subset of your huge game state, where the subset is described by a lens. Olaf

1 0

Second Call for Papers: JFP Special Issue on Program Calculation (papers due 1st Dec)
by Graham Hutton 11 Jul '23

11 Jul '23

================================================================== JFP Special Issue on Program Calculation https://tinyurl.com/prog-calc We invite submissions to the Journal of Functional Programming Special Issue on Program Calculation. Notification of intent : 20 October 2023 Submission deadline : 1 December 2023 SCOPE The idea of program calculation, in which programs are derived from specifications using equational reasoning techniques, has been a topic of interest in functional programming since its earliest days. In particular, the approach allows us to systematically discover how programs can be defined, while at the same time obtaining proofs that they are correct. The aim of this special issue is to document advances that have been made in the field of program calculation in recent years. TOPICS Full-length, archival-quality submissions are solicited on all aspects of program calculation and related topics. Specific topics of interest include but are not limited to: - Program derivation and transformation; - Inductive and co-inductive methods; - Recursion and co-recursion schemes; - Categorical and graphical methods; - Tool support and proof assistants; - Efficiency and resource usage; - Functional algorithm design; - Calculation case studies. The special issue will also consider papers on program calculation that are not traditional research papers. This may include pearls, surveys, tutorials or educational papers, which will be judged by the usual JFP standards for such submissions. Papers will be reviewed as regular JFP submissions, and acceptance in the special issue will be based on both JFP's quality standards and relevance to the theme. NOTIFICATION OF INTENT Authors must notify the special issue editors of their intent to submit by 20 October 2023. The notification of intent should be submitted by filling out the following form, which asks for data to help identify suitable reviewers: tinyurl.com/intent-to-submit If you miss the notification of intent deadline, but still wish to submit, please contact the special-issue editors. SUBMISSIONS Papers must be submitted by 1 December 2023. Submissions should be typeset in LaTeX using the JFP style file, and submitted through the JFP Manuscript Central system. Choose "Program Calculation" as the paper type, so it gets assigned to the special issue. Further author instructions are available from: tinyurl.com/JFP-instructions We welcome extended versions of conference or workshop papers. Such submissions must clearly describe the relationship with the initial publication, and must differ sufficiently that the author can assign copyright to Cambridge University Press. Prospective authors are welcome to discuss submissions with the editors to ensure compliance. SPECIAL-ISSUE EDITORS Graham Hutton <graham.hutton(a)nottingham.ac.uk> Nicolas Wu <n.wu(a)imperial.ac.uk> IMPORTANT DATES We anticipate the following schedule: 20 October 2023 : Notification-of-intent deadline 1 December 2023 : Submission deadline 22 March 2024 : First round of reviews 12 July 2024 : Revision deadline 4 October 2024 : Second round of reviews, if applicable 29 November 2024 : Final versions due ================================================================== 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

Call for Talks: Haskell Implementors' Workshop 2023 (deadline extension)
by Ryan Scott 11 Jul '23

11 Jul '23

TL;DR: The submission deadline for the 2023 Haskell Implementors' Workshop has been extended to June 16. ================================== ACM SIGPLAN Haskell Implementors' Workshop https://icfp23.sigplan.org/home/hiw-2023 Seattle, Washington, United States, September 4, 2023 Co-located with ICFP 2023 https://icfp23.sigplan.org/ Important dates --------------- Deadline: July 16, 2023 (AoE) (extended) Notification: August 4, 2023 Workshop: September 4, 2023 The 15th Haskell Implementors' Workshop is to be held alongside ICFP 2023 this year in Seattle. It is a forum for people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure to share their work and to discuss future directions and collaborations with others. Talks and/or demos are proposed by submitting an abstract, and selected by a small program committee. There will be no published proceedings. The workshop will be informal and interactive, with open spaces in the timetable and room for ad-hoc discussion, demos, and short lightning talks. Scope and target audience ------------------------- It is important to distinguish the Haskell Implementors' Workshop from the Haskell Symposium which is also co-located with ICFP 2023. The Haskell Symposium is for the publication of Haskell-related research. In contrast, the Haskell Implementors' Workshop will have no proceedings -- although we will aim to make talk videos, slides, and presented data available with the consent of the speakers. The Implementors' Workshop is an ideal place to describe a Haskell extension, describe works-in-progress, demo a new Haskell-related tool, or even propose future lines of Haskell development. Members of the wider Haskell community are encouraged to attend the workshop -- we need your feedback to keep the Haskell ecosystem thriving. Students working with Haskell are especially encouraged to share their work. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimisation and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment Talks ----- We invite proposals from potential speakers for talks and demonstrations. We are aiming for 20-minute talks with 5 minutes for questions and changeovers. We want to hear from people writing compilers, tools, or libraries, people with cool ideas for directions in which we should take the platform, proposals for new features to be implemented, and half-baked crazy ideas. Please submit a talk title and abstract of no more than 300 words. Submissions can be made via HotCRP at https://icfp-hiw23.hotcrp.com until July 16 (anywhere on earth). We will also have a lightning talks session. These have been very well received in recent years, and we aim to increase the time available to them. Lightning talks should be ~7mins and are scheduled on the day of the workshop. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. Program Committee ----------------- * Gergő Érdi (Standard Chartered Bank) * Sebastian Graf (Karlsruhe Institute of Technology) * Wen Kokke (University of Strathclyde) * Ryan Scott (Galois, Inc.) * Rebecca Skinner (Mercury) * Li-yao Xia (University of Edinburgh) Contact ------- * Ryan Scott <ryan.gl.scott at gmail.com>

1 1

Representing a type system in Haskell
by Talha Qamar 10 Jul '23

10 Jul '23

Hello everyone, I'm working on a game engine in Haskell. The thing is, while I want to write the architecture in Haskell, I'm thinking of using something else as the actual scripting language. Long story short, how would I represent a type system in Haskell? I've gotten _something_ together that works a bit like this: ``` data Type = -- ...all possible types data Value = -- ...all possible types again data TypedValue = TypedValye Type Value ``` But I'm concerned if this is the ideal way of doing things, particularly when I get to complex types like structs or tagged unions. Any help would be appreciated. Sent from Proton Mail mobile

2 2

Re: [Haskell-cafe] Representing a type system in Haskell
by Talha Qamar 10 Jul '23

10 Jul '23

This looks perfect! I think I'll spend a couple days looking this over and grokking it. Thanks for your time. Sent from Proton Mail mobile -------- Original Message -------- On Jul 10, 2023, 6:56 PM, Brandon Allbery wrote: > You might look at https://web.cecs.pdx.edu/~mpj/thih/thih.pdf which shows how to implement Haskell's own type system (minus various GHC extensions) in Haskell, and adapt to whatever language you're implementing. On Mon, Jul 10, 2023 at 8:36 AM Talha Qamar via Haskell-Cafe wrote: > > > Hello everyone, I'm working on a game engine in Haskell. The thing is, while I want to write the architecture in Haskell, I'm thinking of using something else as the actual scripting language. > > Long story short, how would I represent a type system in Haskell? I've gotten _something_ together that works a bit like this: > > ``` > data Type = -- ...all possible types > data Value = -- ...all possible types again > data TypedValue = TypedValye Type Value > ``` > But I'm concerned if this is the ideal way of doing things, particularly when I get to complex types like structs or tagged unions. > > Any help would be appreciated. > > Sent from Proton Mail mobile > > > _______________________________________________ > Haskell-Cafe mailing list > To (un)subscribe, modify options or view archives go to: > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > Only members subscribed via the mailman list are allowed to post. -- brandon s allbery kf8nh allbery.b(a)gmail.com

1 0

servant streaming question
by Zoran Bošnjak 10 Jul '23

10 Jul '23

Hi all, I would like to reuse some streaming functions from the turtle package in the context of the servant streaming handler. Relevant references: https://hackage.haskell.org/package/turtle-1.6.1/docs/Turtle-Shell.html https://hackage.haskell.org/package/turtle-1.6.1/docs/Turtle-Prelude.html https://hackage.haskell.org/package/servant-0.20/docs/Servant-Types-SourceT… As a simple example: Turtle.Prelude.ls function represents stream of FilePaths (directory listing of some path) ls :: FilePath -> Shell FilePath Servant streaming is based around SourceT IO a, for example: type ListFiles = "ls" :> StreamGet NewlineFraming PlainText (SourceT IO FilePath) The problem is that the streaming (Shell a) is not exactly the same as servant's (SourceT IO a). But as far as I understand, they both represent "stream of values of type 'a'". My question is: Is a generic conversion function possible? Something like: shellToSource :: forall a. Shell a -> SourceIO a shellToSource = ?? ... such that I could reuse the 'ls' and write a streaming servant handler like this: listFilesHandler :: Handler (SourceIO FilePath) listFilesHandler = pure $ shellToSource $ Turtle.Prelude.ls "somePath" Appreciate any suggestion. regards, Zoran

3 3

[ANN] Copilot 3.16
by Ivan Perez 08 Jul '23

08 Jul '23

Hi everyone, We are very excited to announce Copilot 3.16 [2]. Copilot is a stream-based EDSL in Haskell for writing and monitoring embedded C programs, with an emphasis on correctness and hard realtime requirements. Copilot is typically used as a high-level runtime verification framework, and supports temporal logic (LTL, PTLTL and MTL), clocks and voting algorithms. Copilot has been used at NASA in drone test flights. Through the NASA tool Ogma [1] (also written in Haskell), Copilot also serves as a runtime monitoring backend for NASA's Core Flight System, Robot Operating System (ROS2), and FPrime (the software framework used in the Mars Helicopter) applications. This new version provides comprehensive tests for the C99 backend, and introduces a breaking change in the definition of the type `Arg` in copilot-language. For details, see [2]. The new version is already available on Hackage [4]. As always, we're releasing exactly 2 months since the last release. Our next release is scheduled for Sep 7th, 2023. We are also extremely excited to announce that Copilot has received full approval for release as NASA Class D open-source software. Current emphasis is on increasing test coverage for the two remaining libraries without tests (copilot-language and copilot-theorem), removing unnecessary dependencies, hiding internal definitions, and formatting the code to meet our new coding standards. Users are encouraged to participate by opening issues and asking questions via our github repo [3]. There have been many updates on the Copilot front in the last few months. We'll be able to announce more soon. Stay tuned. Happy Haskelling! Ivan [1] https://github.com/nasa/ogma [2] https://github.com/Copilot-Language/copilot/releases/tag/v3.16 [3] https://github.com/Copilot-Language/copilot [4] https://hackage.haskell.org/package/copilot

1 0

PhD position at KU Leuven
by Tom Schrijvers 06 Jul '23

06 Jul '23

Dear Haskell Cafe, I have a PhD position available for a candidate with a master degree in computer science, mathematics or similar and a passion for Haskell, functional programming and programming language theory. For more information and applications, see: https://www.kuleuven.be/personeel/jobsite/jobs/60229600?hl=en&lang=en -- prof. dr. ir. Tom Schrijvers Research Professor KU Leuven Department of Computer Science Celestijnenlaan 200A 3001 Leuven Belgium Phone: +32 16 327 830 http://people.cs.kuleuven.be/~tom.schrijvers/

1 0

Final Call for Talks: Haskell Implementors' Workshop 2023
by Ryan Scott 01 Jul '23

01 Jul '23

The 2023 Haskell Implementors' Workshop deadline is just under one month away. We are looking forward to your talk submissions. Best, Ryan ================================== ACM SIGPLAN Haskell Implementors' Workshop https://icfp23.sigplan.org/home/hiw-2023 Seattle, Washington, United States, September 4, 2023 Co-located with ICFP 2023 https://icfp23.sigplan.org/ Important dates --------------- Deadline: July 4, 2023 (AoE) Notification: August 4, 2023 Workshop: September 4, 2023 The 15th Haskell Implementors' Workshop is to be held alongside ICFP 2023 this year in Seattle. It is a forum for people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure to share their work and to discuss future directions and collaborations with others. Talks and/or demos are proposed by submitting an abstract, and selected by a small program committee. There will be no published proceedings. The workshop will be informal and interactive, with open spaces in the timetable and room for ad-hoc discussion, demos, and short lightning talks. Scope and target audience ------------------------- It is important to distinguish the Haskell Implementors' Workshop from the Haskell Symposium which is also co-located with ICFP 2023. The Haskell Symposium is for the publication of Haskell-related research. In contrast, the Haskell Implementors' Workshop will have no proceedings -- although we will aim to make talk videos, slides, and presented data available with the consent of the speakers. The Implementors' Workshop is an ideal place to describe a Haskell extension, describe works-in-progress, demo a new Haskell-related tool, or even propose future lines of Haskell development. Members of the wider Haskell community are encouraged to attend the workshop -- we need your feedback to keep the Haskell ecosystem thriving. Students working with Haskell are especially encouraged to share their work. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimisation and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment Talks ----- We invite proposals from potential speakers for talks and demonstrations. We are aiming for 20-minute talks with 5 minutes for questions and changeovers. We want to hear from people writing compilers, tools, or libraries, people with cool ideas for directions in which we should take the platform, proposals for new features to be implemented, and half-baked crazy ideas. Please submit a talk title and abstract of no more than 300 words. Submissions can be made via HotCRP at https://icfphiw23.hotcrp.com until July 4 (anywhere on earth). We will also have a lightning talks session. These have been very well received in recent years, and we aim to increase the time available to them. Lightning talks should be ~7mins and are scheduled on the day of the workshop. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. Program Committee ----------------- * Gergő Érdi (Standard Chartered Bank) * Sebastian Graf (Karlsruhe Institute of Technology) * Wen Kokke (University of Strathclyde) * Ryan Scott (Galois, Inc.) * Rebecca Skinner (Mercury) * Li-yao Xia (University of Edinburgh) Contact ------- * Ryan Scott <ryan.gl.scott at gmail.com>

1 1

Re: [Haskell-cafe] type error when specializing lens zooms in ghc >= 9.0
by Olaf Klinke 27 Jun '23

27 Jun '23

> Hm, yikes, I tend to agree this is a very general error message. Here > are > all the places "83865" shows up in the code base: > > > https://gitlab.haskell.org/search?search=83865&project_id=1&group_id=2&sear… > > I opened https://gitlab.haskell.org/ghc/ghc/-/issues/23466 to follow > up. > Feel free to weigh in. (Contact me if you need an account - spam > measures > currently include manual approvals for new accounts.) > Thanks, Bryan. This made me wonder what the current system behind assignment of error codes is. I'd expect five-digit error codes to be *more* specific than the general shape of error message emitted by ghc, but here it is evidently less specific. 82865 stands for the error message constructor TypeEqMismatch [1] which is a record [2] with many fields. In particular, the teq_mismatch_expected and teq_mismatch_actual fields hold structural information: a ForAllTy [3] may hint at simplified subsumption. Thus my proposal would be that error codes are composite values, with one part (as currently implemented) in bijection to the error message constructor and another part determined by a function of the actual error value. This function has to be chosen to provide sufficient abstraction from the actual situation but e.g. differentiate between constructors of the Type type. For example, why don't the cases differentiated by the pretty-printer [4] not own their own error codes? Olaf [1] https://gitlab.haskell.org/ghc/ghc/-/blob/master/compiler/GHC/Types/Error/C… [2] https://hackage.haskell.org/package/ghc-9.6.1/docs/src/GHC.Tc.Errors.Types.… [3] https://hackage.haskell.org/package/ghc-9.6.1/docs/src/GHC.Core.TyCo.Rep.ht… [4] https://hackage.haskell.org/package/ghc-9.6.1/docs/src/GHC.Tc.Errors.Ppr.ht…

2 1

ICFP 2023: Call for Volunteers (Deadline: 30 June!)
by ICFP Publicity 27 Jun '23

27 Jun '23

ICFP 2023 CALL FOR VOLUNTEERS 28th ACM SIGPLAN International Conference on Functional Programming https://icfp23.sigplan.org/track/icfp-2023-volunteers Sign up to be a Volunteer and help us make ICFP 2023 a unique experience for all attendants! ICFP 2023 is pleased to offer a number of opportunities for volunteers, who are vital to the efficient operation and continued success of the conference each year. The volunteer program is a chance for people from around the world to participate in the conferences whilst assisting us in preparing and running the event. The Volunteer Program helps more people attend the ICFP conference by covering conference fees, including access to the banquet (but not travel or lodging expenses) in exchange for a fixed number of work hours (usually from 12 to 15) helping with the conference organization. ## How to apply Please apply using this form (https://forms.gle/27pzbztJq5PVCZeW9) The deadline is June 30th ## Eligibility Everyone is welcome to apply. Priority is given to junior members of our community, e.g. full- or part-time students of computer science and related fields. ## Expectation Applicants must be available for at least four (4) full days between September 4th and September 9th, 2023, and will be expected to provide a total of 12-15 hours of volunteering work in that time. The skills, talents, and dedication of our Volunteers contribute to the overall quality of the conference. The Volunteer role this year will mainly involve working with the organizers to prepare for the conference by providing technical assistance to attendees, managing online Q&A and poster sessions, and supporting active communication in our online environment. ## Compensation * A Complimentary Conference Registration, offering access to all open sessions (i.e., parallel paper presentations, demonstrations, and workshops) and conference proceedings. * Free lunches and refreshments during breaks. * Volunteer garments. * Free admission to all social events. Please note that volunteers are responsible for their own travel and accommodation arrangements. If you need additional travel funding, please consider SIGPLAN PAC Funding (http://www.sigplan.org/PAC/) and PLMW (https://icfp23.sigplan.org/track/plmw-icfp-2023)

1 0

Munich Haskell Meeting, 2023-06-27 @ 19:30
by Leah Neukirchen 25 Jun '23

25 Jun '23

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

1 0

wiki-account-request
by Val Saven 23 Jun '23

23 Jun '23

Hi! I would like to create an account for https://wiki.haskell.org with the username ValSaven. Thanks in advance.

1 0

Keelung Compiler is now open source!
by Ting Wang 20 Jun '23

20 Jun '23

Hello developers, We are thrilled to announce that Keelung is now 100% open source! By making it transparent under the Apache 2.0 license, we aim to increase accessibility and foster contributions from the community. The Keelung Compiler transforms programs written in Keelung, a new domain-specific language (DSL) designed to make fast, private, and secure applications, into constraint systems for proof generation and verification. It includes an interpreter for program execution during development and a solver for generating witnesses in constraint systems. Anticipate a more powerful Keelung! Upcoming updates include seamless Keelung-Haskell integration and unsigned integers with limitless bit-widths. Cheers, BTQ team Blog post: https://www.btq.com/blog/keelung-compiler-is-now-open-source Discord: https://discord.gg/j5rMMZ3nVh Keelung Language repo: https://github.com/btq-ag/keelung Keelung Compiler repo: https://github.com/btq-ag/keelung-compiler

1 0

IFL23 2nd Call for papers
by Pieter Koopman 19 Jun '23

19 Jun '23

Important Dates Draft Paper Submission Deadline 31st July, 2023 Notification of Acceptance for Presentation 1st August, 2023 Early Registration Deadline 11th August, 2023 Late Registration Deadline 23rd August, 2023 IFL Symposium 29th - 31st August, 2023 Submission of Papers for Peer-Reviewed Proceedings 24th November, 2023 Notification of Acceptance 2nd February, 2024 Camera-ready Version 8th March, 2024 SCOPE AND TOPICS The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. You can find more information about the symposium on its oficial website <https://ifl21-publicity-dot-yamm-track.appspot.com/2IbpUfdKDWXA46mxX19BBo6B…>. IFL 2023 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. See the call for papers in text format <https://ifl21-publicity-dot-yamm-track.appspot.com/2qMy_CjkGt-iRL4j6F-587fo…> . Areas of interest include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - abstract interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - embedded domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - industrial applications PAPER SUBMISSIONS Following IFL tradition, IFL 2023 will use a post-symposium review process to produce the formal proceedings. Before the symposium, authors submit draft papers. These draft papers will be screened by the program chair to make sure that they are within the scope of IFL. The draft papers will be made available to all participants at the symposium. Each draft paper is presented by one of the authors at the symposium. Notice that it is a requirement that accepted draft papers are presented physically at the symposium. After the symposium every presenter is invited to submit a full paper, incorporating feedback from discussions at the symposium. Work submitted to IFL may not be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy. The program committee will evaluate these submissions according to their correctness, novelty, originality, relevance, significance, and clarity, and will thereby determine whether the paper is accepted or rejected for the formal proceedings. As in previous years, we will try to have the papers that are accepted for the formal proceedings published in the International Conference Proceedings Series of the ACM Digital Library. This possibility will be confirmed as soon as possible. Reviewing is single blind. There will be at least 3 reviews per paper. For the camera-ready version the authors can make minor revisions which are accepted without further reviewing. Papers must use the ACM two columns conference format, which can be found here <https://ifl21-publicity-dot-yamm-track.appspot.com/28XmEeVXZZu8IKuIdzJ4p17Y…>. (For LaTeX users, start your document with \documentclass[sigconf,screen,review]{acmart}.) All contributions must be written in English. Note that this format has a rather long but limited list of packages that can be used. Please make sure that your document adheres to this list. The page limit for papers is twelve pages (excluding references). Only papers that were presented at the IFL 2023 Symposium will be considered for publication. LOCATION IFL 2023 will be held physically in Braga, Portugal. For more information, click here <https://ifl21-publicity-dot-yamm-track.appspot.com/2MQQxmzMf0C1rQZIaJ0CQdWt…> . [image: beacon]

1 0

SPLASH 2023 - Second Combined Call for Contributions
by Alcides Fonseca 17 Jun '23

17 Jun '23

====================================================================== Second Combined Call For Contributions ACM Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH'23) October 22-27, 2023, Cascais, Portugal https://2023.splashcon.org ====================================================================== SPLASH - The ACM SIGPLAN conference on Systems, Programming, Languages, and Applications: Software for Humanity embraces all aspects of software construction and delivery, to make it the premier conference on the applications of programming languages - at the intersection of programming languages and software engineering. Follow the registration space on the SPLASH website to attend this fantastic line-up of events - we aim to open for registration on July 20. ====================================================================== OUTLINE OF THE SECOND COMBINED CALL FOR CONTRIBUTIONS: SPLASH upcoming deadlines: * Posters (deadline: 15 Aug) * SPLASH-E (deadline: 27 Jul) * Doctoral Symposium (deadline: 7 Jul) * Student Research Competition (deadline: 14 Jul) * Programming Languages Mentoring Workshop (PLMW) (deadline: 24 Jul) SPLASH Workshops (submission deadline: 12 Jul): * CONFLANG * FTSCS * HATRA * IWACO * LIVE * PAINT * PLF * REBELS * ST30 SPLASH Co-located Events: * DLS (Deadline: 28 Jun) * GPCE (Deadline: 7 July) * MPLR (Deadline: 26 Jun) ====================================================================== SPLASH - The ACM SIGPLAN conference on Systems, Programming, Languages, and Applications: Software for Humanity embraces all aspects of software construction and delivery, to make it the premier conference on the applications of programming languages - at the intersection of programming languages and software engineering. SPLASH 2023 aims to signify the reopening of the world and being able to meet your international colleagues in person. ** Co-located Events ** **** Dynamic Languages Symposium (DLS) **** The Dynamic Languages Symposium (DLS) is the premier forum for researchers and practitioners to share research and experience on all aspects of dynamic languages. After two decades of dynamic language research and DLS, it is time to reflect and look forward to what the next two decades will bring. This year's DLS will therefore be a special DLS focusing on the Future of Dynamic Languages. To do the notion of "symposium" justice, we will actively invite speakers to present their opinions on where Dynamic Languages might be, will be, or should be going in the next twenty years. Paper Submission Deadline: 28 Jun 2023 Details: https://2023.splashcon.org/home/dls-2023 **** Generative Programming: Concepts & Experiences (GPCE)**** ACM SIGPLAN International Conference on Generative Programming: Concepts & Experiences (GPCE) is a venue for researchers and practitioners interested in techniques that use program generation, domain-specific languages, and component deployment to increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative software, our goal is to foster further cross-fertilization between the software engineering and the programming languages research communities. Abstract Submission Deadline: 3 Jul 2023 Paper Submission Deadline: 7 Jul 2023 Details: https://2023.splashcon.org/home/gpce-2023 **** Managed Programming Languages & Runtimes (MPLR)**** The 20th International Conference on Managed Programming Languages & Runtimes (MPLR'23, formerly ManLang, originally PPPJ) is a premier forum for presenting and discussing novel results in all aspects of managed programming languages and runtime systems, which serve as building blocks for some of the most important computing systems around, ranging from small-scale (embedded and real-time systems) to large-scale (cloud-computing and big-data platforms) and anything in between (mobile, IoT, and wearable applications). Paper/Abstract Submission Deadline: 26 Jun 2023 Details: https://2023.splashcon.org/home/mplr-2023 **** Posters **** The SPLASH Posters track provides an excellent forum for authors to present their recent or ongoing projects in an interactive setting, and receive feedback from the community. We invite submissions covering any aspect of programming, systems, languages and applications. The goal of the poster session is to encourage and facilitate small groups of individuals interested in a technical area to gather and interact. It is held early in the conference, to promote continued discussion among interested parties. Submission Deadline: 15 Aug 2023 **** SPLASH-E **** SPLASH-E is a symposium, started in 2013, for software and languages (SE/PL) researchers with activities and interests around computing education. Some build pedagogically-oriented languages or tools; some think about pedagogic challenges around SE/PL courses; some bring computing to non-CS communities; some pursue human studies and educational research. At SPLASH-E, we share our educational ideas and challenges centered in software/languages, as well as our best ideas for advancing such work. SPLASH-E strives to bring together researchers and those with educational interests that arise from software ideas or concerns. Archival Submission Deadline: 27 Jul 2023 ** Student Research Competition (SRC) ** The ACM Student Research Competition (SRC) offers a unique opportunity for undergraduate and graduate students to present their research to a panel of judges and conference attendees at SPLASH. The SRC provides visibility and exposes up-and-coming researchers to computer science research and the research community. This competition also gives students an opportunity to discuss their research with experts in their field, get feedback, and sharpen their communication and networking skills. Abstract Submission Deadline: 14 Jul 2023 ** Programming Languages Mentoring Workshop (PLMW) ** The SPLASH Programming Languages Mentoring Workshop encourages graduate students (PhD and MSc) and senior undergraduate students to pursue research in programming languages. This workshop will provide mentoring sessions on how to prepare for and thrive in graduate school and in a research career, focusing both on cutting-edge research topics and practical advice. The workshop brings together leading researchers and junior students in an inclusive environment in order to help welcome newcomers to our field of programming languages research. The workshop will show students the many paths that they might take to enter and contribute to our research community. Application Submission Deadline: 24 Jul 2023 ** Workshops ** **** CONFLANG **** CONFLANG is a workshop on the design, the theory, the practice and the future evolution of configuration languages. It aims to gather the emerging community in this area in order to engage in fruitful interactions, to share ideas, results, opinions, and experiences on languages for configuration. Correct configuration is an actual industrial problem, and would greatly benefit from existing and ongoing academic research. Dually, this is a space with new challenges to overcome and new directions to explore, which is a great opportunity to confront new ideas with large-scale production. **** FTSCS **** The aim of this workshop is to bring together researchers and engineers who are interested in the application of formal and semi-formal methods to improve the quality of safety-critical computer systems. FTSCS strives to promote research and development of formal methods and tools for industrial applications, and is particularly interested in industrial applications of formal methods. Specific topics include, but are not limited to: case studies and experience reports on the use of formal methods for analyzing safety-critical systems, including avionics, automotive, medical, railway, and other kinds of safety-critical and QoS-critical systems; methods, techniques and tools to support automated analysis, certification, debugging, etc., of safety/QoS-critical systems; analysis methods that address the limitations of formal methods in industry (usability, scalability, etc.); formal analysis support for modeling languages used in industry, such as AADL, Ptolemy, SysML, SCADE, Modelica, etc.; code generation from validated models. The workshop will provide a platform for discussions and the exchange of innovative ideas, so submissions on work in progress are encouraged. **** HATRA **** Programming language designers seek to provide strong tools to help developers reason about their programs. For example, the formal methods community seeks to enable developers to prove correctness properties of their code, and type system designers seek to exclude classes of undesirable behavior from programs. The security community creates tools to help developers achieve their security goals. In order to make these approaches as effective as possible for developers, recent work has integrated approaches from human-computer interaction research into programming language design. This workshop brings together programming languages, software engineering, security, and human-computer interaction researchers to investigate methods for making languages that provide stronger safety properties more effective for programmers and software engineers. We have two goals: (1) to provide a venue for discussion and feedback on early-stage approaches that might enable people to be more effective at achieving stronger safety properties in their programs; (2) to facilitate discussion about relevant topics of participant interest. **** IWACO **** Many techniques have been introduced to describe and reason about stateful programs, and to restrict, analyze, and prevent aliases. These include various forms of ownership types, capabilities, separation logic, linear logic, uniqueness, sharing control, escape analysis, argument independence, read-only references, linear references, effect systems, and access control mechanisms. These tools have found their way into type systems, compilers and interpreters, runtime systems and bug-finding tools. Their immediate practical relevance is self-evident from the popularity of Rust, a programming language built around reasoning about aliasing and ownership to enable static memory management and data race freedom, voted the "most beloved" language in the annual Stack Overflow Developer Survey seven times in a row. IWACO'23 will focus on these techniques, on how they can be used to reason about stateful (sequential or concurrent) programs, and how they have been applied to programming languages. In particular, we will consider papers on: models, type systems and other formal systems, programming language mechanisms, analysis and design techniques, patterns and notations for expressing ownership, aliasing, capabilities, uniqueness, and related topics; empirical studies of programs or experience reports from programming systems designed with these techniques in mind; programming logics that deal with aliasing and/or shared state, or use ownership, capabilities or resourcing; applications of capabilities, ownership and other similar type systems in low-level systems such as programming languages runtimes, virtual machines, or compilers; and optimization techniques, analysis algorithms, libraries, applications, and novel approaches exploiting ownership, aliasing, capabilities, uniqueness, and related topics. **** LIVE **** Programming is cognitively demanding, and too difficult. LIVE is a workshop exploring new user interfaces that improve the immediacy, usability, and learnability of programming. Whereas PL research traditionally focuses on programs, LIVE focuses more on the activity of programming. Our goal is to provide a supportive venue where early-stage work receives constructive criticism. Whether graduate students or tenured faculty, researchers need a forum to discuss new ideas and get helpful feedback from their peers. Towards that end, we will allot about ten minutes for discussion after every presentation. **** PAINT **** Programming environments that integrate tools, notations, and abstractions into a holistic user experience can provide programmers with better support for what they want to achieve. These programming environments can create an engaging place to do new forms of informational work - resulting in enjoyable, creative, and productive experiences with programming. In the workshop on Programming Abstractions and Interactive Notations, Tools, and Environments (PAINT), we want to discuss programming environments that support users in working with and creating notations and abstractions that matter to them. We are interested in the relationship between people centric notations and general-purpose programming languages and environments. How do we reflect the various experiences, needs, and priorities of the many people involved in programming — whether they call it that or not? **** PLF **** Applications supporting multi-device are ubiquitous. While most of the distributed applications that we see nowadays are cloud-based, avoiding the cloud can lead to privacy and performance benefits for users and operational and cost benefits for companies and developers. Following this idea, Local-First Software runs and stores its data locally while still allowing collaboration, thus retaining the benefits of existing collaborative applications without depending on the cloud. Many specific solutions already exist: operational transformation, client-side databases with eventually consistent replication based on CRDTs, and even synchronization as a service provided by commercial offerings, and a vast selection of UI design libraries. However, these solutions are not integrated with the programming languages that applications are developed in. Language based solutions related to distribution such as type systems describing protocols, reliable actor runtimes, data processing, machine learning, etc., are designed and optimized for the cloud not for a loosely connected set of cooperating devices. This workshop aims at bringing the issue to the attention of the PL community, and accelerating the development of suitable solutions for this area. **** REBELS **** Reactive programming and event-based programming are two closely related programming styles that are becoming ever more important with the advent of advanced HPC technology and the ever increasing requirement for our applications to run on the web or on collaborating mobile devices. A number of publications on middleware and language design — so-called reactive and event-based languages and systems (REBLS) — have already seen the light, but the field still raises several questions. For example, the interaction with mainstream language concepts is poorly understood, implementation technology is in its infancy and modularity mechanisms are almost totally lacking. Moreover, large applications are still to be developed and patterns and tools for developing reactive applications is an area that is vastly unexplored. This workshop will gather researchers in reactive and event-based languages and systems. The goal of the workshop is to exchange new technical research results and to define better the field by coming up with taxonomies and overviews of the existing work. **** ST30 **** Session types are a type-theoretic approach to specifying communication protocols so that they can be verified by type-checking. This year marks 30 years since the first paper on session types, by Kohei Honda at CONCUR 1993. Since then the topic has attracted increasing interest, and a substantial community and literature have developed. Google Scholar lists almost 400 articles with "session types" in the title, and most programming language conferences now include several papers on session types each year. In terms of the technical focus, there have been continuing theoretical developments (notably the generalisation from two-party to multi-party session types by Honda, Yoshida and Carbone in 2008, and the development of a Curry-Howard correspondence with linear logic by Caires and Pfenning in 2010) and a variety of implementations of session types as programming language extensions or libraries, covering (among others) Haskell, OCaml, Java, Scala, Rust, Python, C#, Go. ST30 is a workshop to celebrate the 30th anniversary of session types by bringing together the community for a day of talks and technical discussion. ====================================================================== Be part of these fantastic events! ====================================================================== Organizing Committee General Chair: Vasco T. Vasconcelos (University of Lisbon) OOPSLA Review Committee Chair: Mira Mezini (TU Darmstadt) OOPSLA Publications Co-Chair: Ragnar Mogk (TU Darmstadt) OOPSLA Artifact Evaluation Co-Chair: Benjamin Greenman (Brown University) OOPSLA Artifact Evaluation Co-Chair: Guillaume Baudart (INRIA) DLS General Chair: Stefan Marr (University of Kent) GPCE General Chair: Bernhard Rumpe (RWTH Aachen University) GPCE PC Chair: Amir Shaikhha (University of Edinburgh) LOPSTR PC Chair: Robert Glück (University of Copenhagen, Denmark) LOPSTR PC Chair: Bishoksan Kafle (IMDEA) MPLR General Chair: Rodrigo Bruno (University of Lisbon) MPLR PC Chair: Elliot Moss (University of Massachusetts Amherst) PPDP PC Chair: Santiago Escobar (Universitat Politècnica de València ) SAS Co-Chair: Manuel Hermenegildo (Technical University of Madrid & IMDEA) SAS Co-Chair: José Morales (IMDEA) SAS Artifact Evaluation Chair: Marc Chevalier (Snyk) SLE Chair: João Saraiva (University of Minho) SLE PC Co-Chair: Thomas Degueule (CNRS, LaBRI) SLE PC Co-Chair: Elizabeth Scott (Royal Holloway University of London) Onward! Papers Chair: Tijs van der Storm (CWI & University of Groningen) Onward! Essays Chair: Robert Hirschfeld (University of Potsdam; Hasso Plattner Institute) SPLASH-E Co-Chair: Molly Feldman (Oberlin College) Posters Co-Chair: Xujie Si (University of Toronto) Workshops Co-Chair: Mehdi Bagherzadeh (Oakland University) Workshops Co-Chair: Amin Alipour (University of Houston) Hybridisation Co-Chair: Youyou Cong (Tokyo Institute of Technology) Hybridisation Co-Chair: Jonathan Immanuel Brachthäuser (University of Tübingen) Video Co-Chair: Guilherme Espada (University of Lisbon) Video Co-Chair: Apoorv Ingle (University of Iowa) Publicity Chair, Web Co-Chair: Andreea Costea (National University Of Singapore) Publicity Chair, Web Co-Chair: Alcides Fonseca (University of Lisbon) PLMW Co-Chair: Molly Feldman (Oberlin College) PLMW Co-Chair: Youyou Cong (Tokyo Institute of Technology) PLMW Co-Chair: João Ferreira (University of Lisbon) Sponsoring Co-Chair: Bor-Yuh Evan Chang (University of Colorado Boulder & Amazon) Sponsoring Co-Chair: Nicolas Wu (Imperial College London) Student Research Competition Co-Chair: Xujie Si (McGill University, Canada) Local Organizer Chair: Andreia Mordido (University of Lisbon) SIGPLAN Conference Manager: Neringa Young

1 0

Multicolumn aggregate in Beam
by Daneel Yaitskov 06 Jun '23

06 Jun '23

Hi, I am using beam library in my project and trying to express a query with a several aggregating subqueries: select (select * from t order by ts desc limit 1), (select * from t order by ts asc limit 1), (select count(*) from t) as nnn I figured out how to do multiple columns: userDataTableDigestQ :: UserTable -> SqlSelect Postgres (UserDataTable, UserDataTable) userDataTableDigestQ ut = select ag where al = all_ (userDataTableRef $ usertableName ut) ag = subselect_ $ aggregate_ (BF.bimap group_ group_) ((,) <$> limit_ 1 (orderBy_ (asc_ . userdatatableTs) al) <*> limit_ 1 (orderBy_ (desc_ . userdatatableTs) al)) but mixing group_ and count_ produces a very long type error Is there other sql-backend agnostic Haskell library which could express the query above? -- Best regards, Daniil Iaitskov

1 0

Journal of Functional Programming - Call for PhD Abstracts
by Graham Hutton 05 Jun '23

05 Jun '23

Dear all, If you or one of your students recently completed a PhD (or Habilitation) 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 30th June 2023. Please share! Best wishes, Graham Hutton ============================================================ CALL FOR PHD ABSTRACTS Journal of Functional Programming Deadline: 30th June 2023 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 student and the advisor/supervisor although we encourage them to coordinate. Habilitation dissertations are also eligible for inclusion. ============================================================ SUBMISSION: Please submit the following information to Graham Hutton <graham.hutton(a)nottingham.ac.uk> by 30th June 2023. o Dissertation title: (including any subtitle) o Student: (full name) o Awarding institution: (full name and country) o Date of 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

Course materials to help me teach Software Engineering with Haskell?
by Ignat Insarov 04 Jun '23

04 Jun '23

Hello café! I am looking for some kind of lesson plans, lecture notes or other inspiring materials that would help me construct an advanced course in Software Engineering with Haskell — or other pure functional technologies — with the aim to teach this art to myself and others to the highest level of excellence. I know there is a choice of published books with «Haskell» in the title, and I shall draw from them. However, I am not super happy about any of the books I looked into so far, because they are so concrete. They would pick a bunch of best practices and some well known libraries and write about that in excruciating detail. It seems a published book cannot afford to say anything abstract or outlandish. Assorti lecture notes I could find on the Internet are more diverse and fresh, but I have not found many and whichever I found are all somewhat beginner level, they talk about Haskell's syntax and evaluation more than about Software Engineering overall. The stuff I wish to see would be like: * Continuation passing style. * Recursion schemes. * Polynomial functors. * The nature of `IO`. * Evaluation of Haskell on a graph machine. * The expression problem. In short, stuff that transcends specific libraries and concrete code. In the ideal, I wish there was a literature review that refers to foundational research. I do not expect ready-made perfection; please send me whatever you think would help, even your brief thoughts and wishes.

2 1

Re: [Haskell-cafe] [hledger] ANN: hledger 1.30
by Simon Michael 02 Jun '23

02 Jun '23

> On Jun 2, 2023, at 00:55, Henning Thielemann <googlegroups(a)henning-thielemann.de> wrote: > > I can build with GHC-8.8.4, but with GHC-8.10 and later I get: > > > Hledger/Cli/Commands/Demo.hs:63:3: error: > • Exception when trying to run compile-time code: > /ram/cabal/tmp/src-191030/hledger-1.30/embeddedfiles/add.cast: openFile: does not exist (No such file or directory) > Code: embedFileRelative "embeddedfiles/add.cast" > • In the untyped splice: > $(embedFileRelative "embeddedfiles/add.cast") > | > 63 | $(embedFileRelative "embeddedfiles/add.cast"), -- https://asciinema.org/a/567935 The easiest way to start a journal (add) > | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Thanks for the report; I have released hledger-1.30.1 on Hackage to fix this.

1 0

could not deduce Show compile error
by Zoran Bošnjak 02 Jun '23

02 Jun '23

Dear haskell cafe members, I would appreciate a suggestion how to fix compile error on this simple test program (I am using ghc 9.0.2). The idea is to have 'data Flow a b' unrestricted and create necessary constraints only when running/interpreting the flow. The problem is obviously an intermediate type 'b' in 'Compose', where the 'Show' instance is not deduced. I have a vague clue that some type families might be necessary to propagate Show constraint, or a type class with associated type family, but I don't know exactly how. --- import Prelude hiding ((.), id) import Control.Category data Flow a b where Id :: Flow a a Compose :: Flow a b -> Flow b c -> Flow a c instance Category Flow where id = Id (.) = flip Compose runFlow :: Show a => Flow a b -> a -> IO b runFlow f x = case f of Id -> print x >> pure x Compose f1 f2 -> runFlow f1 x >>= runFlow f2 main :: IO () main = runFlow (Id >>> Id) () --- The error is: • Could not deduce (Show b1) arising from a use of ‘runFlow’ from the context: Show a bound by the type signature for: runFlow :: forall a b. Show a => Flow a b -> a -> IO b at a02.hs:13:1-42 Possible fix: add (Show b1) to the context of the data constructor ‘Compose’ • In the second argument of ‘(>>=)’, namely ‘runFlow f2’ In the expression: runFlow f1 x >>= runFlow f2 In a case alternative: Compose f1 f2 -> runFlow f1 x >>= runFlow f2 | 16 | Compose f1 f2 -> runFlow f1 x >>= runFlow f2 | ^^^^^^^^^^ kind regards, Zoran

3 3

type error when specializing lens zooms in ghc >= 9.0
by Olaf Klinke 02 Jun '23

02 Jun '23

Dear Cafe, I'm an infrequent lens user so please forgive me if the below problem has a trivial solution. For a long time the documentation of Control.Lens.Zoom has been claiming that 'zoom' and 'magnify' can be specialized to the following types. {-# LANGUAGE RankNTypes #-} -- Type error with GHC 9.0.2 or 9.2.7, okay with GHC 8.8.4 import Control.Lens.Zoom (zoom,magnify) import Control.Lens.Type (Lens') import Control.Monad.RWS (RWS) zoomRWS :: Monoid w => Lens' s s' -> RWS r w s' a -> RWS r w s a zoomRWS = zoom magnifyRWS :: Monoid w => Lens' r r' -> RWS r' w s a -> RWS r w s a magnifyRWS = magnify Indeed GHC 8.8.4 compiles this happily (on lens-4.18.1), but 9.0.2 (on lens-5.0.1) throws nearly undecipherable errors, claiming that Lens' can not be matched with some more specialized type involving Magnified and LensLike. The source of Control.Lens.Zoom does not differ substantially between 4.18.1 and 5.0.1 so my guess is it is a type checker issue. Can anyone explain? On which bug tracker should I raise this issue, if it is indeed a valid one? (I pulled the above versions from stackage lts-16.31, -19.5 and -20.20, respectively and compiled with stack.) Thanks Olaf

4 6

[CfP][CONFLANG23] 2nd Workshop on Configuration Languages
by Yann Hamdaoui 02 Jun '23

02 Jun '23

Dear Haskellers, and maybe more generally programming language enthusiasts, I am happy to announce the 2nd Workshop on Configuration Languages, co-located at SPLASH 23, and focused on the quite peculiar (and thus, exciting!) space of designing configuration languages, and more general configuration and infrastructure management. Cheers, Yann CALL FOR PRESENTATIONS - 2nd Workshop on Configuration Languages 2023 (CONFLANG23) EVENT DETAILS Event: CONFLANG23, colocated at SPLASH 2023 Date: Tuesday 24 October 2023 Submission deadline: Friday 12 July 2023 Location: Cascais, Portugal Website: https://2023.splashcon.org/home/conflang-2023 OVERVIEW CONFLANG is a new workshop on the design, the usage and the tooling of configuration programming languages. CONFLANG aims at uniting language designers, industry practitioners and passionate hobbyists to share knowledge in any form. Topics of interest include, but are not limited to: - Infrastructure and configuration code maintenance and evolution - Specification learning and mining for configurations - Infrastructure and Configuration testing and verification - Infrastructure as Code and configuration repair - New languages for configuration - The application of language security and type theory to program configuration CALL FOR PRESENTATIONS The committee welcomes proposals for presentations: - Traditional talks on any theoretical or practical aspect of the usage, the tooling and the design of configuration languages - Experience and case study talks on the real world usage and deployment of configuration languages - Explorative talks and/or demos on experimenting with configuration languages and related tools SUBMISSION GUIDELINES Please submit an abstract (up to 600 words, excluding title, author names, and bibliography) of your proposed talk using the submission link provided below. - **Format**: 600 words maximum abstract (estimated between 1 and 1,5 pages) as a PDF, excluding title, author names, and bibliography. Any additional material will be considered at the discretion of the PC. - **URL** : https://conflang23.hotcrp.com/ PROGRAM CHAIRS - Yann Hamdaoui (Tweag) - Jürgen Cito (TU Wien and Facebook) - Mark Santolucito (Columbia University) - Marcel van Lohuizen (CUE Lang)

1 0

ANN: hledger 1.30
by Simon Michael 02 Jun '23

02 Jun '23

I'm pleased to announce hledger 1.30 ! Highlights: - Boolean queries - with the new `expr:` query type you can freely combined other queries with AND, OR, NOT and parentheses. - Easier CSV file management - you can now read a CSV .rules file, and let it fetch the data file from a downloads directory, simplifying CSV file management. - Built-in demos - a new `demo` command plays several asciinema casts to demonstrate features. We'll add more of these in future. - hledger-ui has a new Cash accounts screen, and now starts on the Menu screen. - The usual miscellaneous fixes. Thank you release contributors Chris Lemaire and Yehoshua Pesach Wallach. - https://github.com/simonmichael/hledger/releases/1.30 - https://hledger.org/release-notes.html#hledger-1-30 - https://hledger.org/install What is hledger ? - Fast, reliable, free, multicurrency, double-entry, plain text accounting software for unix, mac, windows, and the web - Built around human-readable, version-controllable plain text files - Inspired by and largely compatible with Ledger CLI, convertible to and from Beancount - Written in Haskell for reliability and longevity. For help getting started or more info, see https://hledger.org and join our Matrix/IRC chat or mail list: https://hledger.org/support . Newcomers, experts, contributors, sponsors, feedback are welcome! For more about plain text accounting, see https://plaintextaccounting.org . Live well and prosper, -Simon

1 0

property testing, point-free style
by Olaf Klinke 31 May '23

31 May '23

Dear Cafe, The expression \x -> f x == g x is a testable property, as long as values for x can be randomly generated. For clarity I'd prefer a point-free style, e.g. f ≡ g Are there extensions to QuickCheck that let me write this? The QuickCheck package itself does not seem to contain such an operator. My current work-around is a newtype ExtensionalEquality a b that holds two functions of type (a -> b) and a Testable instance for it. But I've got a hunch that I re-invented some wheel here. (My ExtensionalEquality is isomorphic to Refl (a -> b) (a -> b) but Refl ist conceptually about type equality, not term equality.) Thanks Olaf

3 3

Call for Papers: JFP Special Issue on Program Calculation
by Graham Hutton 30 May '23

30 May '23

Dear all, We're delighted to announce a Special Issue on Program Calculation for the Journal of Functional Programming. Please share, and submit your best papers! Best wishes, Graham Hutton and Nicolas Wu Guest Editors ================================================================== JFP Special Issue on Program Calculation We invite submissions to the Journal of Functional Programming Special Issue on Program Calculation: tinyurl.com/prog-calc Notification of intent : 20 October 2023 Submission deadline : 1 December 2023 SCOPE The idea of program calculation, in which programs are derived from specifications using equational reasoning techniques, has been a topic of interest in functional programming since its earliest days. In particular, the approach allows us to systematically discover how programs can be defined, while at the same time obtaining proofs that they are correct. The aim of this special issue is to document advances that have been made in the field of program calculation in recent years. TOPICS Full-length, archival-quality submissions are solicited on all aspects of program calculation and related topics. Specific topics of interest include but are not limited to: - Program derivation and transformation; - Inductive and co-inductive methods; - Recursion and co-recursion schemes; - Categorical and graphical methods; - Tool support and proof assistants; - Efficiency and resource usage; - Functional algorithm design; - Calculation case studies. The special issue will also consider papers on program calculation that are not traditional research papers. This may include pearls, surveys, tutorials or educational papers, which will be judged by the usual JFP standards for such submissions. Papers will be reviewed as regular JFP submissions, and acceptance in the special issue will be based on both JFP's quality standards and relevance to the theme. NOTIFICATION OF INTENT Authors must notify the special issue editors of their intent to submit by 20 October 2023. The notification of intent should be submitted by filling out the following form, which asks for data to help identify suitable reviewers: tinyurl.com/intent-to-submit If you miss the notification of intent deadline, but still wish to submit, please contact the special-issue editors. SUBMISSIONS Papers must be submitted by 1 December 2023. Submissions should be typeset in LaTeX using the JFP style file, and submitted through the JFP Manuscript Central system. Choose "Program Calculation" as the paper type, so it gets assigned to the special issue. Further author instructions are available from: tinyurl.com/JFP-instructions We welcome extended versions of conference or workshop papers. Such submissions must clearly describe the relationship with the initial publication, and must differ sufficiently that the author can assign copyright to Cambridge University Press. Prospective authors are welcome to discuss submissions with the editors to ensure compliance. SPECIAL-ISSUE EDITORS Graham Hutton <graham.hutton(a)nottingham.ac.uk> Nicolas Wu <n.wu(a)imperial.ac.uk> IMPORTANT DATES We anticipate the following schedule: 20 October 2023 : Notification-of-intent deadline 1 December 2023 : Submission deadline 22 March 2024 : First round of reviews 12 July 2024 : Revision deadline 4 October 2024 : Second round of reviews, if applicable 29 November 2024 : Final versions due ================================================================== 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