- Haskell-Cafe - Haskell.org

Question on Lexing Haskell syntax
by Travis Athougies 02 Nov '23

02 Nov '23

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 According to the Haskell report [1] (See Note 5), a virtual `}` token is inserted if parsing the next token would cause a parse error and the indentation stack is non-empty. I'm trying to lex and parse Haskell source and this sort of interplay (which requires two-way communication between lexer and parser) makes it very difficult to write a conformant implementation. I can't change the standard (obviously), but I'm wondering if this is actually what GHC (de facto the only Haskell compiler) does, or if it applies some other rule. If so, does anyone know the exact mechanism of its implementation? I've been programming Haskell for more than a decade, and while I have an intuitive understanding of the indentation rules, I would have assumed the source could be lexed without also having a parser. In particular, the note seems to imply that the main purpose of this is to properly lex `let`/`in` bindings. Perhaps there's an alternate equivalent rule? Curious to hear other's thoughts. Travis [1] https://www.haskell.org/onlinereport/haskell2010/haskellch10.html#x17-17800… -----BEGIN PGP SIGNATURE----- iIsEARYKADMWIQRW81c55hOCXuY5k/H+BxaRGQDTjQUCZUGARhUcdHJhdmlzQGF0 aG91Z2llcy5uZXQACgkQ/gcWkRkA041W+wEA/7n5NejGTYu4O6N+Pt7Rn0bBRw6D 5D96idagahXqXioA/18hxYFpY45lWwB7pKCh83xQJu2Bcwkxj1xhhCEZBcoA =FrDy -----END PGP SIGNATURE-----

5 6

Munich Haskell Meeting, 2023-10-31 @ 19:30
by Leah Neukirchen 30 Oct '23

30 Oct '23

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Tuesday, October 31 at Iveria (Lindwurmstraße 159A) 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/7ST4pxNRVj3rGLdO Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

2 1

Re: [Haskell-cafe] Should GHC 9.4.7 be native on MacBook Air M2?
by David Banas 29 Oct '23

29 Oct '23

Ah, I needed this line in my stack.yaml file: arch: aarch64 Why is that? Shouldn’t it use the native architecture if it can support it? -db

2 1

Should GHC 9.4.7 be native on MacBook Air M2?
by David Banas 28 Oct '23

28 Oct '23

I’m working on a new MacBook Air M2. I just bumped my current Haskell project to stack LTS-21.17, after catching up on the GHC porting effort news. I did a stack clean / stack build and saw GHC 9.4.7 being installed, as expected, but still to the x86_64-osx directory: % l ~/.stack/programs x86_64-osx % l ~/.stack/programs/x86_64-osx ghc-8.10.3 ghc-8.10.4.tar.bz2 ghc-8.6.3.installed ghc-9.0.2 ghc-9.2.2.tar.bz2 ghc-9.2.7.installed ghc-8.10.3.installed ghc-8.4.3 ghc-8.6.3.tar.bz2 ghc-9.0.2.installed ghc-9.2.5 ghc-9.2.7.tar.bz2 ghc-8.10.3.tar.bz2 ghc-8.4.3.installed ghc-8.6.5 ghc-9.0.2.tar.bz2 ghc-9.2.5.installed ghc-9.4.7 ghc-8.10.4 ghc-8.4.3.tar.bz2 ghc-8.6.5.installed ghc-9.2.2 ghc-9.2.5.tar.bz2 ghc-9.4.7.installed ghc-8.10.4.installed ghc-8.6.3 ghc-8.6.5.tar.bz2 ghc-9.2.2.installed ghc-9.2.7 ghc-9.4.7.tar.bz2 I was expecting a native version; do I misunderstand something?

1 0

Simplest way to move a ... `using` ... line into the IO monad?
by David Banas 27 Oct '23

27 Oct '23

Hi all, What is the simplest way to translate a non-monadic line of Haskell code, such as: res = map foo xs `using` parList rseq For use in the IO monad? This doesn’t work: res <- mapM fooM xs `using` parTraversable rseq complaining: No Traversable instance for IO. Thanks, -db

4 6

Re: [Haskell-cafe] when does ghc(i) expand type synonyms?
by Olaf Klinke 26 Oct '23

26 Oct '23

> ghci> :set +t > > ghci> "foo" > "foo" > it :: String > > ghci> reverse "foo" > "oof" > it :: [Char] I'm not a GHC expert, but my guess is: It must have something to do with unifying the argument types with the type signature of the function. In (<>), the two argument and the result types are identical. Hence it can be safely said that x <> whatever as long as this expression is valid, has the same type as x. In contrast, the result type of (++) is always of the shape [a]. Hence String gets unified with [a] which forces expansion of the type synonym. Consider: class Foo a where {rev :: a -> a; conc :: a -> a -> a} instance Foo [a] where {rev = reverse; conc = (++)} revconc :: Foo a => a -> a; revconc a = conc a (rev a) :t revconc ("foo" :: String) revconc ("foo" :: String) :: String So as long has you hide (++) in a type signature that proves input and output are the same, synonyms don't get expanded. Olaf

1 0

when does ghc(i) expand type synonyms?
by Johannes Waldmann 25 Oct '23

25 Oct '23

Dear cafe, my students were asking: why are types printed differently here? ghci> :set +t ghci> "foo" "foo" it :: String ghci> reverse "foo" "oof" it :: [Char] ... and I add ghci> fst ("foo", 42) "foo" it :: String compiler docs do not really explain the difference https://downloads.haskell.org/ghc/latest/docs/users_guide/ghci.html#ghci-cm… (it says "display the type of .." while technically it is "display some representation of the type of ..."?) I found this explanation of a somewhat related issue https://gitlab.haskell.org/ghc/ghc/-/issues/9183#note_83743 While playing around with this, I noticed: ghci> let x = "foo" in (x <> reverse x) "foooof" it :: String ghci> let x = "foo" in (x ++ reverse x) "foooof" it :: [Char] Well, it's just optics: when I extract the type programmatically, the synonym necessarily does get expanded ghci> import Data.Data ghci> typeOf (let x = "foo" in (x <> reverse x)) [Char] it :: TypeRep - Johannes

2 1

Hackage not building package
by Ivan Perez 23 Oct '23

23 Oct '23

Hi, I recently uploaded a package ( https://hackage.haskell.org/package/dunai-0.12.0) and hackage is not building it. I don't see info anywhere and I cannot re-trigger a build: attempting to do so shows the message "Report not found -Build report does not exist" Is everything ok with hackage? Thanks Ivan

2 1

Where did pem-0.2.4 come from? a.k.a. is anyone compelled to take-over this project?
by Noon van der Silk 19 Oct '23

19 Oct '23

Glancing at hackage, I happened to noticed that pem is at 0.2.4 - https://hackage.haskell.org/package/pem-0.2.4 Glancing at the repo, I notice that pem is at 0.2.3 - https://github.com/vincenthz/hs-pem It seems there _is_ a tag for 0.2.4, but `master` has not been updated <https://github.com/vincenthz/hs-pem/compare/master..pem-v0.2.4>. Is there anyone out there that feels compelled or excited to fix this? And perhaps relatedly, given vincent has archived all these repos; perhaps there could be a kind of "global takeover" by the HF cryptography working group of these projects? -- Noon van der Silk, ن http://silky.github.io/ "My programming language is kindness."

2 1

Request for take over: graphviz
by Daniel Casanueva 18 Oct '23

18 Oct '23

Hello, graphviz [1] maintenance has been inactive for a long time now. Revisions have been published, but the maintainer seems unresponsive. Last year, Bodigrim suggested the package needs a new maintainer in a GitHub thread [2] that one month ago I found while looking if someone had already done the fix I needed. I'm happy to help keeping the package alive so, about a month ago, I emailed Ivan (graphviz's author) to the e-mail address from his GitHub profile, offering my assistance with graphviz. I haven't gotten any answer yet, so I thought I should be making my offer public, as indicated by the "Taking over a package" wikipage [3]. I don't have big change plans for graphviz. Most likely I will just be patching it to keep it working with future GHC releases and reviewing/accepting PRs. Thank you, Daniel [1] https://hackage.haskell.org/package/graphviz [2] https://github.com/ivan-m/graphviz/pull/53#issuecomment-1261496914 [3] https://wiki.haskell.org/Taking_over_a_package

1 0

Assistant Prof at Barnard College, Columbia U
by Mark Santolucito 17 Oct '23

17 Oct '23

Hi all, Barnard College, Columbia University has an opening for an Assistant Professor: https://cs.barnard.edu/assistant-professor-computer-science-2024 The deadline is Oct 27 for full consideration. Barnard is the women's college of Columbia and has a 2-2 teaching load (typically with additional reductions). If you are interested, please feel free to reach out to me directly to discuss more. This is a unique place that I have really enjoyed the past few years! Mark https://www.marksantolucito.com/

1 0

CFP: Workshop on Hardware Acceleration of Functional and Declarative Languages
by Rob Stewart 17 Oct '23

17 Oct '23

Hi haskell-cafe, Call for participation: HAFDAL 2024 The 1st Workshop on Hardware Acceleration of Functional and Declarative Languages (HAFDAL) will be co-located with HPCA, Edinburgh on March 2nd or 3rd 2024. This workshop will bring together computer architects and programming language implementers to explore software/hardware co-designs of high level execution models. We invite two forms of participation: (1) full paper submissions for 30 minute talks, (2) 5-10 minute lightning talks about related projects and early results. For full papers, we are looking for submissions that cover the motivation, design, or real-world application of hardware technology for functional/declarative languages, their compilers and runtime systems. Submission deadline: 20 November 2023. The call for participation and all key dates are here: https://haflang.github.io/images/hafdal24_cfp.pdf The workshop's website is: https://haflang.github.io/workshops/hafdal24.html Best wishes, Rob Stewart Associate Professor Mathematical and Computer Sciences Heriot-Watt University

1 0

Release: stan, supporting GHCs 8.8-9.4
by Tom Ellis 15 Oct '23

15 Oct '23

I'm pleased to announce a new release of `stan`, a static analysis tool for Haskell. `stan` now supports GHCs in the range 8.8-9.4[1]. ### About `stan` Stan is a command-line tool for analysing Haskell projects. It discovers which parts of the code can potentially be improved, and offers suggestions on how to do so. Read more about `stan` in its [`README`](https://github.com/kowainik/stan/#what-this-tool-is-about). ### Installation I recommend obtaining `stan` from Hackage by following [the installation instructions in the README](https://github.com/kowainik/stan/#hackage). https://hackage.haskell.org/package/stan-0.1.0.0 ### Help wanted `stan` lacks active maintainers and is currently in essential maintainance only mode. I am helping out to make sure `stan` can continue to build with newer GHCs. I would welcome assistance, particularly on the following issues: * Supporting GHC 9.6 * Supporting GHC 9.8 * Prospective support for GHC 9.10 * Fixing caching on Github Actions If you would like to contribute to Stan please [create an issue](https://github.com/kowainik/stan/issues) on the Github repository. ### Credits Thanks to the Kowainik team for creating `stan` in the first place. Thanks to Veronika Romashkina for accepting me as a new maintainer for the project. ---- [1] Some point releases are excluded because the GHC API doesn't seem to provide enough type information, notably the later releases in the 9.2 series.

1 1

CFP: Workshop on the Implementation of Type Systems (WITS) '24
by Richard Eisenberg 13 Oct '23

13 Oct '23

---------------------------------------------------------------------- CALL FOR CONTRIBUTIONS 3rd Workshop on the Implementation of Type Systems WITS 2024 January 20, 2024 London, United Kingdom https://popl24.sigplan.org/home/wits-2024 <https://popl24.sigplan.org/home/wits-2024> ---------------------------------------------------------------------- WITS 2024 is the third Workshop on the Implementation of Type Systems. The workshop will be held on January 20, 2024, in London, United Kingdom, co-located with POPL. The goal of this workshop is to bring together the implementors of a variety of languages with advanced type systems. The main focus is on the practical issues that come up in the implementation of these systems, rather than the theoretical frameworks that underlie them. In particular, we want to encourage exchanging ideas between the communities around specific systems that would otherwise be accessible to only a very select group. The workshop will have a mix of invited and contributed talks, organized discussion times, and informal collaboration time. *Scope* We invite participants to share their experiences, study differences among the implementations, and generalize lessons from those. We also want to promote the creation of a shared vocabulary and set of best practices for implementing type systems. Here are a few examples of topics we are interested to discuss: * syntax with binders and substitution * conversion modulo beta and eta * implicit arguments and metavariables * unification and constraint solving * metaprogramming and tactic languages * editor integration and automation * discoverability of language features * pretty printing and error messages This list is not exhaustive, so please contact the PC chairs in case you are unsure if a topic falls within the scope of the workshop. *Submissions* WITS solicits two kinds of submissions: * Contributed talks on the basis of an abstract. This can be on recently published or submitted work, work in progress, or a project that is still in the idea phase. * Proposals for roundtable discussions. This can be on any topic within the scope of the workshop, but should have a broader scope than a contributed talk. If accepted, you will be in charge of leading a discussion of 45 minutes around the proposed topic together with other interested attendees. Both kinds of proposals should be accompanied by an abstract of max. 1 page (exclusive of references), formatted according to the guidelines for SIGPLAN conferences: use the `sigplan` option to the `acmart` LaTeX document class. WITS will have no published proceedings, so submitting to WITS does not interfere with submission (before, after, or simultaneously) with other venues. Submissions are handled via https://wits24.hotcrp.com/ <https://wits24.hotcrp.com/>. *Important Dates* - Abstract submission deadline: 10 November, 2023 (AoE) - Notification: 1 December, 2023 - Workshop in London: 20 January, 2024 *Attendance and registration* WITS 2024 is colocated with POPL 2024 in London, UK. Information on registration and attendance will be posted on the POPL website at https://popl24.sigplan.org/ <https://popl24.sigplan.org/>. *Program Committee* Lennart Augustsson Epic Games, Sweden Edwin Brady St. Andrews, UK Jesper Cockx TU Delft, Netherlands co-chair Richard Eisenberg Jane Street, USA co-chair Jacques-Henri Jourdan CRNS, France Matthieu Sozeau INRIA, France Ningning Xie U. of Toronto, Canada

1 0

[ANNOUNCE] GHC 9.8.1 is now available
by Ben Gamari 13 Oct '23

13 Oct '23

The GHC developers are very pleased to announce the availability of the final release of GHC 9.8.1. Binary distributions, source distributions, and documentation are available at downloads.haskell.org: https://downloads.haskell.org/ghc/9.8.1 GHC 9.8 brings 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][]. Plans for GHC's future releases can be found on the [GHC Wiki][status]. 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. 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/docs/users_guide/9.8.1-notes.html [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status

6 7

ambiguous type variable question
by Zoran Bošnjak 11 Oct '23

11 Oct '23

Hi all, I want to convert a type level structure to the value level structure of the same shape. This is the simplified example: {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE UndecidableInstances #-} module Test where import GHC.TypeLits import Data.Kind import Data.Proxy -- This data structure serves both for 'type level' and 'value level'. data Content n s b = ContentRaw | ContentTable [(n, s)] | ContentBool b deriving instance (Show n, Show s, Show b) => Show (Content n s b) -- Convert from types to values. class IsSchema s where type SchemaVal s :: Type schema :: SchemaVal s instance IsSchema 'ContentRaw where type (SchemaVal 'ContentRaw) = Content Integer String Bool schema = ContentRaw instance IsSchema ('ContentTable '[]) where type (SchemaVal ('ContentTable '[])) = Content Integer String Bool schema = ContentTable [] instance ( IsSchema ('ContentTable ts) , t ~ '(n, s), KnownNat n, KnownSymbol s , SchemaVal ('ContentTable ts) ~ Content Integer String Bool ) => IsSchema ('ContentTable (t ': ts)) where type SchemaVal ('ContentTable (t ': ts)) = Content Integer String Bool schema = case schema @('ContentTable ts) of ContentTable lst -> let n = natVal (Proxy @n) s = symbolVal (Proxy @s) in ContentTable ((n,s) : lst) _ -> error "internal error" If I remove the type parameter 'b', 'ContentBool b' and coresponding 'Bool' from the sample, the conversion works as expected. >>> schema @'ContentRaw ContentRaw >>> schema @('ContentTable ( '(1,"test1") ': '(2,"test2") ': '[])) ContentTable [(1,"test1"),(2,"test2")] But for some reason, as soon as I extend the example with 'b' and 'Bool' as shown above, it results in the following error: * Could not deduce (SchemaVal ('ContentTable ts) ~ Content Integer String b0) from the context: (IsSchema ('ContentTable ts), t ~ '(n, s), KnownNat n, KnownSymbol s, SchemaVal ('ContentTable ts) ~ Content Integer String Bool) bound by the instance declaration at test2.hs:(34,5)-(37,43) The type variable `b1' is ambiguous How do I fix it or how do I rewrite it to get the intended result? regards, Zoran

2 7

Call for Contributions: BOB 2024 [March 15, Deadline Nov 17]
by Stefan Wehr 11 Oct '23

11 Oct '23

================================================================================ BOB Conference 2024 "What happens when we use what's best for a change?" https://bobkonf.de/2024/cfc.html Berlin, Mar 17 Call for Contributions Deadline: November 17, 2023 ================================================================================ You are actively engaged in advanced software engineering methods, solve ambitious problem with software and are open to cutting-edge innovation? Attend this conference, meet people that share your goals, and get to know the best software tools and technologies available today. We strive to offer a day full of new experiences and impressions that you can use to immediately improve your daily life as a software developer. If you share our vision and want to contribute, submit a proposal for a talk or tutorial! NOTE: The conference fee will be waived for presenters. Travel expenses will not be covered (for exceptions see "Speaker Grants"). Shepherding ----------- The program committee offers shepherding to all speakers. Shepherding provides speakers assistance with preparing their sessions. Specifically: - advice on structure and presentation - review of talk slides - assistance with recording - review of recording, if applicable Speaker Grants -------------- BOB has Speaker Grants available to support speakers from groups under-represented in technology. We specifically seek women speakers, speakers of color, and speakers who are not able to attend the conference for financial reasons. Topics ------ We are looking for talks about best-of-breed software technology, e.g.: - functional programming - persistent data structures and databases - event-based modelling and architecture - "fancy types" (dependent types, gradual typing, linear types, ...) - formal methods for correctness and robustness - abstractions for concurrency and parallelism - metaprogramming - probabilistic programming - math and programming - controlled side effects - program synthesis - next-generation IDEs - effective abstractions for data analytics - … everything really that isn’t mainstream, but you think should be - … includeing rough ideas worth discussing. Presenters should provide the audience with information that is practically useful for software developers. Challenges ---------- Furthermore, we seek contributions on successful approaches for solving hard problems, for example: - bias in machine-learning systems - digital transformation in difficult settings - accessibiltity - systems with critical reliability requirements - ecologically sustainable software development We're especially interested in experience reports. Other topics are also relevant, e.g.: - introductory talks on technical background - overviews of a given field - demos and how-tos Requirements ------------ We accept proposals for presentations of 45 minutes (40 minutes talk + 5 minutes questions), as well as 90 minute tutorials for beginners. The language of presentation should be either English or German. Your proposal should include (in your presentation language of choice): - An abstract of max. 1500 characters. - A short bio/cv - Contact information (including at least email address) - A list of 3-5 concrete ideas of how your work can be applied in a developer's daily life - additional material (websites, blogs, slides, videos of past presentations, …) Organisation ------------ - Direct questions to konferenz at bobkonf dot de - Proposal deadline: November 17, 2023 - Notification: December 5, 2023 - Program: December 12, 2023 Submit here: https://pretalx.com/bob-2024/submit/ Program Committee ----------------- (more information here: https://bobkonf.de/2024/programmkomitee.html) - Matthias Fischmann, Wire - Matthias Neubauer, SICK AG - Nicole Rauch, Softwareentwicklung und Entwicklungscoaching - Michael Sperber, Active Group - Stefan Wehr, Hochschule Offenburg Scientific Advisory Board - Annette Bieniusa, TU Kaiserslautern - Torsten Grust, Uni Tübingen - Peter Thiemann, Uni Freiburg

1 0

[Haskell] [ANNOUNCE] Haskell Language Server 2.4.0.0 released
by Zubin Duggal 10 Oct '23

10 Oct '23

Binaries for this release are available at https://downloads.haskell.org/~hls/haskell-language-server-2.4.0.0/. These binaries can be installed using [GHCup](https://www.haskell.org/ghcup/) or the Haskell VSCode extension. All of these tarballs have associated GPG signatures. The signature should be from `Zubin Duggal <zubin(a)well-typed.com>` (key ID [588764FBE22D19C4](https://keys.openpgp.org/search?q=588764FBE22D19C4)) The prebuilt binaries in this release support the following GHC versions: - 9.0.2 - 9.2.8 - 9.4.7 - 9.6.3 - 9.8.1 # Changelog * Initial support for GHC 9.8.1, without plugins dependent on `ghc-exactprint` * Fix broken Windows binaries (#3822) Happy editing! - Zubin

1 0

XMonad for Wayland — seeking help
by Brandon Allbery 08 Oct '23

08 Oct '23

We on the XMonad devteam (Tomáš, Tony, Yecine, and myself) have been collecting contributions for the past two years with an eye toward paying someone to work on a port of XMonad to Wayland, since none of us is up to the task. We think we now have enough contributions coming in monthly to pay for someone to work with us on it. Problem is, we have no idea who can do this. So this is a call for help, looking for someone who can write it. There is an existing project <https://github.com/L-as/waymonad> but it’s badly bitrotted, including using a very old and buggy version of wlroots <https://gitlab.freedesktop.org/wlroots>, and L-as has had little time to revisit it. It’s not clear that it’s worth revisiting. One problem that’s unlikely to be solvable is that Wayland programs don’t set distinct identifiers that a manageHook could use, so the appName and className hooks can’t be ported. We welcome information to the contrary, though. So, help? Comments and especially proposals welcome on the Discourse thread <https://discourse.haskell.org/t/xmonad-for-wayland-call-for-help/7812>. -- brandon s allbery kf8nh allbery.b(a)gmail.com

1 0

[ANNOUNCE] Agda 2.6.4
by Andreas Abel 06 Oct '23

06 Oct '23

Dear all, The Agda Team is very pleased to announce the release of Agda 2.6.4. Thanks to everyone who gave us feedback on the release candidates! # Highlights of Agda 2.6.4 * Cubical Agda now displays boundary conditions in interactive mode (PR [#6529](https://github.com/agda/agda/pull/6529)). * An inconsistency in the treatment of large indices has been fixed (Issue [#6654](https://github.com/agda/agda/issues/6654)). * Unfolding of definitions can now be fine-controlled via `opaque` definitions. * Additions to the sort system: `LevelUniv` and `Propω`. * New flag `--erasure` with several improvements to erasure (declared run-time irrelevance). * New reflection primitives for meta-programming. # GHC supported versions Agda 2.6.4 has been tested with GHC 9.6.3, 9.4.7, 9.2.8, 9.0.2, 8.10.7, 8.8.4 and 8.6.5 on Linux, macOS and Windows. # Installation Agda 2.6.4 can be installed using cabal-install or stack: 1. Getting the tarball $ cabal update $ cabal get Agda-2.6.4 $ cd Agda-2.6.4 2. a. Using cabal-install $ cabal install -f +optimise-heavily -f +enable-cluster-counting 2. b. Using stack $ stack --stack-yaml stack-a.b.c.yaml install --flag Agda:optimise-heavily --flag Agda:enable-cluster-counting replacing `a.b.c` with your version of GHC. The flags mean: - optimise-heavily: Turn on extra optimisation for a faster Agda. Takes large resources during compilation of Agda. - enable-cluster-counting: Enable unicode clusters for alignment in the LaTeX backend. Requires the ICU lib to be installed and known to pkg-config. These flags can be dropped from the install if causing trouble. # Standard library You can use standard library v1.7.2 or the `master` branch of the standard library with Agda 2.6.4. This branch is available at https://github.com/agda/agda-stdlib/ # Fixed issues over Agda 2.6.3 https://hackage.haskell.org/package/Agda-2.6.4/changelog Enjoy Agda! Andreas, on behalf of the Agda Team _______________________________________________ Agda mailing list Agda(a)lists.chalmers.se https://lists.chalmers.se/mailman/listinfo/agda

1 0

Meaning of fizzled sparks?
by David Banas 04 Oct '23

04 Oct '23

Hi all, If this code: f5Rslts = map (f5 (n-1) startingMinScore startingMaxScore (otherColor clr) 0) newBoards `using` parList rdeepseq totalMoves = sum $ map snd f5Rslts -- Attempt at parallelization yielded no perf. improvement. is yielding a fizzled spark ratio of about 0.3, does it imply that the sum begins pulling from the list, before the sparks have had a chance to compute the first third of the list elements? Thanks, -db

2 1

CFP, PEPM 2024 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation
by Meng Wang 03 Oct '23

03 Oct '23

Dear Haskellers, Gabriele and I are organising PEPM this year. Over the years, PEPM has grown into a conference of general PL topics and Haskell/FP is strongly represented. We look forward to receiving your submissions. Best regards, Gabriele Keller (Utrecht University, Netherlands) Meng Wang (University of Bristol, UK) ---------------------------------------------------------------------------------------------------------- ** ** CALL FOR PAPERS ** ** PEPM at POPL 2024 ** Workshop on PARTIAL EVALUATION AND PROGRAM MANIPULATION ** 16th of January 2024, London, United Kingdom ** ** Submission Deadline: ** 18 October 2023 ** ** https://popl24.sigplan.org/home/pepm-2024 ** https://easychair.org/conferences/?conf=pepm24 ** ----------------------------------------------------------------------------------------------------------- ACM SIGPLAN Workshop on PARTIAL EVALUATION AND PROGRAM MANIPULATION (PEPM) 2024 =============================================================================== * Website : https://popl24.sigplan.org/home/pepm-2024 * Time : 16th January 2024 * Place : London, United Kingdom (co-located with POPL 2024) The ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation (PEPM) has a history going back to 1991 and has been co-located with POPL every year since 2006. It originated with the discoveries of useful automated techniques for evaluating programs with only partial input. Over the years, the scope of PEPM has expanded to include a variety of research areas centred around the theme of semantics-based program manipulation — the systematic exploitation of treating programs not only as subjects to black-box execution but also as data structures that can be generated, analysed, and transformed while establishing or maintaining important semantic properties. Scope ----- In addition to the traditional PEPM topics (see below), PEPM 2024 welcomes submissions in new domains, in particular: * Semantics based and machine-learning based program synthesis and program optimisation. * Modelling, analysis, and transformation techniques for distributed and concurrent protocols and programs, such as session types, linear types, and contract specifications. More generally, topics of interest for PEPM 2024 include, but are not limited to: * Program and model manipulation techniques such as: supercompilation, partial evaluation, fusion, on-the-fly program adaptation, active libraries, program inversion, slicing, symbolic execution, refactoring, decompilation, and obfuscation. * Techniques that treat programs/models as data objects including metaprogramming, generative programming, embedded domain-specific languages, program synthesis by sketching and inductive programming, staged computation, and model-driven program generation and transformation. * Program analysis techniques that are used to drive program/model manipulation such as: abstract interpretation, termination checking, binding-time analysis, constraint solving, type systems, automated testing and test case generation. * Application of the above techniques including case studies of program manipulation in real-world (industrial, open-source) projects and software development processes, descriptions of robust tools capable of effectively handling realistic applications, benchmarking. Examples of application domains include legacy program understanding and transformation, DSL implementations, visual languages and end-user programming, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, embedded and resource-limited computation, and security. This list of categories is not exhaustive, and we encourage submissions describing new theories and applications related to semantics-based program manipulation in general. If you have a question as to whether a potential submission is within the scope of the workshop, please contact the programme co-chairs, Gabriele Keller (g.k.keller(a)uu.nl<mailto:g.k.keller@uu.nl>) and Meng Wang (meng.wang(a)bristol.ac.uk<mailto:meng.wang@bristol.ac.uk>). Submission categories and guidelines ------------------------------------ Three kinds of submissions will be accepted: * Regular Research Papers should describe new results, and will be judged on originality, correctness, significance, and clarity. Regular research papers must not exceed 12 pages. * Short Papers may include tool demonstrations and presentations of exciting if not fully polished research, and of interesting academic, industrial, and open-source applications that are new or unfamiliar. Short papers must not exceed 6 pages. * Talk Proposals may propose lectures about topics of interest for PEPM, existing work representing relevant contributions, or promising contributions that are not mature enough to be proposed as papers of the other categories. Talk Proposals must not exceed 2 pages. References and appendices are not included in page limits. Appendices may not necessarily be read by reviewers. Both kinds of submissions should be typeset using the two-column ‘sigplan’ sub-format of the new ‘acmart’ format available at: http://sigplan.org/Resources/Author/ and submitted electronically via EasyChair: https://easychair.org/conferences/?conf=pepm24 Reviewing will be single-blind. Submissions are welcome from PC members (except the two co-chairs). Accepted regular research papers will appear in formal proceedings published by ACM, and be included in the ACM Digital Library. Accepted short papers do not constitute formal publications and will not appear in the proceedings. At least one author of each accepted contribution must attend the workshop (physically or virtually) and present the work. In the case of tool demonstration papers, a live demonstration of the described tool is expected. Important dates --------------- * Paper submission deadline : **Wednesday 18th October 2023 (AoE)** * Author notification : **Wednesday 15th November 2023 (AoE)** * Workshop : **Tuesday 16th January 2024** Best paper award ---------------- PEPM 2024 continues the tradition of a Best Paper award. The winner will be announced at the workshop. Programme committee ------------------- * Chairs: Gabriele Keller (Utrecht University, Netherlands) Meng Wang (University of Bristol, UK)

1 1

Meaning of "GC waiting" in ThreadScope?
by David Banas 03 Oct '23

03 Oct '23

Hi all, When viewing the result of my code execution in ThreadScope, What does it imply when there’s a great amount of time spent in the “GC waiting” phase, but only short little blips of time spent in the “GC” phase? Thanks, -db

1 0

two HLS processes with same name
by Dennis Raddle 03 Oct '23

03 Oct '23

I'm running the HLS plugin in VS Code on MacOS, on an M2 Apple Silicon MacBook Pro. My computer is running low on RAM and the HLS process seems to be fairly large for me (over 1 GB). When I first run VS Code on a Haskell workspace, there is one process called "haskell-language-server-9.2.8". Eventually another process, taking an additional 1 GB, joins it. The two processes have the same name. Is it supposed to work like this? Note about Apple Silicon FYI: I bought this computer in June with 16 GB Integrated RAM. RAM is very expensive in a SoC. I'm discovering that a lot of programs are memory hogs, not sure if it's the latest MacOS or M2, but between running software development stuff and music-related apps, I'm running out of RAM. I just bought a similar MacBook but with 32 GB RAM, and will sell the current one. So eventually I won't worry about an extra GB process or two. Dennis

4 5

Taking over maintainership of `fec`
by Jean-Paul Calderone 02 Oct '23

02 Oct '23

Hello all, I would like to take over maintainership of the `fec` package ( https://hackage.haskell.org/package/fec) fec is a wrapper around a C library for a certain forward erasure code scheme. Neither the C library nor the Haskell bindings have changed much since the package was last published on Hackage but recently I've fixed a multithreading bug that leads to corrupt results and an integer overflow bug that leads to memory corruption and typically a segfault. I would love to make these improvements available via Hackage. I don't think `fec` has much of a user base but I've recently published several cryptographic libraries on Hackage which depend on it and suffer from the two issues mentioned above. I'm also an upstream maintainer of the project (https://github.com/tahoe-lafs/zfec) I have emailed the current maintainer and original author of the Haskell bindings, Adam Langley (cced), about becoming a maintainer but I haven't yet heard back. Thanks, Jean-Paul

2 5

Using deriving with indexed data types
by Tom Ellis 30 Sep '23

30 Sep '23

How are Haskell folks using indexed types (indexed by types of DataKinds) whilst still being able to take advantage of GHC's deriving? I wrote up my approach into a small library: https://github.com/tomjaguarpaw/ad/blob/589926448865700fa616e8c6f6e4a011384… Here's an example of using my approach: https://github.com/tomjaguarpaw/ad/blob/master/indexed-types/src/IndexedTyp… and it shows you can still use deriving for all your instances: https://github.com/tomjaguarpaw/ad/blob/master/indexed-types/src/IndexedTyp… I'd be interested to know what other approaches people are using in practice. Thanks, Tom

1 1

[ANNOUNCE] GHC 9.8.1-rc1 is now available
by Ben Gamari 29 Sep '23

29 Sep '23

The GHC developers are very pleased to announce the availability of the release candidate of GHC 9.8.1. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.8.1-rc1 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 candidate includes roughly 20 new commits relative to alpha 4, including what we believe should be nearly the last changes to GHC's boot libraries. As always, GHC's release status can be found on the GHC Wiki [status]. 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-alpha4/docs/users_guide/9.8.1-notes… [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status

1 0

[Haskell] [ANNOUNCE] Haskell Language Server 2.3.0.0 released
by Zubin Duggal 29 Sep '23

29 Sep '23

Binaries for this release are available at https://downloads.haskell.org/~hls/haskell-language-server-2.3.0.0/. These binaries can be installed using [GHCup](https://www.haskell.org/ghcup/) or the Haskell VSCode extension. All of these tarballs have associated GPG signatures. The signature should be from `Zubin Duggal <zubin(a)well-typed.com>` (key ID [588764FBE22D19C4](https://keys.openpgp.org/search?q=588764FBE22D19C4)) The prebuilt binaries in this release support the following GHC versions: - 9.0.2 - 9.2.8 - 9.4.6 - 9.6.2 - 9.6.3 ## Changelog * Binaries for GHC 9.6.3 * Drop support for GHC 8.10 * Remove `hls-haddock-comments-plugin`, `hls-stan-plugin`, and `hls-tactics-plugin` * Don't suggest bogus modules names in `hls-module-name-plugin` (#3784) * Add support for external Ormolu (#3771) * Improve refine imports behaviour for qualified imports (#3806) Happy editing! - Zubin

1 0

How can I get in touch with Stan maintainers?
by Tom Ellis 28 Sep '23

28 Sep '23

Hello, Does anyone know how I can get in touch with the Stan maintainers? Stan is a static analysis tool for Haskell. Its maintainers seem to have stopped supporting it after the GHC 8.x series because the GHC API changed too frequently for them to want to keep making adjustments. Last year I did quite a lot of work to bring Stan and its dependencies up to 9.4. I made a PR to the Stan Github repo last month: https://github.com/kowainik/stan/pull/506 I haven't heard anything from the maintainers. The only maintainer I know of is Veronika Romashkina. I've sent her a private email about this but had no response. Does anyone know how I can get in contact with Veronika or another Stan maintainer, if there is one? I would be willing to be a comaintainer for Stan and the rest of the Kowainik ecosystem (if only to make sure they continue to work with future GHCs). Thanks, Tom

1 0

[ANNOUNCE] GHC 9.6.3 is now available
by Bryan Richter 25 Sep '23

25 Sep '23

The GHC developers are happy to announce the availability of GHC 9.6.3. Binary distributions, source distributions, and documentation are available on the release page. https://www.haskell.org/ghc/download_ghc_9_6_3.html This release is primarily a bugfix release addressing a few issues found in the 9.6 series. These include: * Disable Polymorphic Specialisation (a performance optimisation) by default. It was discovered that Polymorphic Specialisation as currently implemented in GHC can lead to hard to diagnose bugs resulting in incorrect runtime results. Users wishing to use this optimisation despite the caveats will now have to explicitly enable the new `-fpolymorphic-specialisation` flag. For more details see #23469 as well as #23109, #21229, #23445. * Improve compile time and code generation performance when `-finfo-table-map` is enabled (#23103). * Make the recompilation check more robust when code generation flags are changed (#23369). * Addition of memory barriers that improve soundness on platforms with weak memory ordering. * And dozens of other fixes. A full accounting of changes can be found in the [release notes]. As some of the fixed issues do affect correctness users are encouraged to upgrade promptly. We would like to thank Microsoft Azure, GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, 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 [GHC ticket] if you see anything amiss. Enjoy! -Bryan [release notes]: https://downloads.haskell.org/~ghc/9.6.3/docs/users_guide/9.6.3-notes.html [GHC ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

1 0

[ANNOUNCE] GHC 9.8.1-alpha4 is now available
by Ben Gamari 23 Sep '23

23 Sep '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-alpha4 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 40 new commits relative to alpha 3, 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-alpha4/docs/users_guide/9.8.1-notes…

3 4

Munich Haskell Meeting, 2023-09-25 @ 19:30
by Leah Neukirchen 22 Sep '23

22 Sep '23

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

1 0

Re: [Haskell-cafe] Limitations of generalization of type constructors
by Ryan Scott 18 Sep '23

18 Sep '23

Short answer: This is expected behavior, and it's unlikely that behavior will change any time soon. Long answer: The key phrase in your original post is "the quantifier moved". That is, in this definition: > fc3 :: Int > fc3 = f (const 0) GHC will turn it into something like this behind the scenes when compiling it to Core: > fc3 :: Int > fc3 = f (\ (@z). const @Int @(Maybe z) 0 :: forall (z :: Type). Maybe z -> Int) Note the presence of `\ (@z)`, which binds a type variable with a lambda. This process of moving quantifiers by using type variables in lambdas is called *regeneralization*. A somewhat surprising fact is that GHC can only perform regeneralization some of the time. GHC can regeneralize type-level `forall`s—that is, `forall`s in the types of terms, as is the case in the example above—but it cannot regeneralize *kind*-level `forall`s. In your post, the `forall`s in the kinds of C2 and Const are kind-level `forall`s. This restriction is documented here [1] in the GHC User's Guide. I've also written a slightly longer blog post [2] about the topic. The reason why this restriction exists is because there is no type-level counterpart to `\ (@z)` in Core, which would be required for regeneralization at the kind level. Adding type-level lambdas to Core would likely be a non-trivial effort. The UnsaturatedTypeFamilies proposal [3], which proposes to relax some restrictions about when types can appear partially applied, is the closest thing that I can think of, but it stops short of proposing full type-level lambdas. Best, Ryan ----- [1] https://downloads.haskell.org/ghc/9.6.2/docs/users_guide/exts/poly_kinds.ht… [2] https://ryanglscott.github.io/2019/07/10/the-surprising-rigidness-of-higher… [3] https://github.com/ghc-proposals/ghc-proposals/blob/7e380dcc4494de30f95bd15…

2 1

Re: [Haskell-cafe] Why can't I promote data family constructors, and what to do instead?
by Ryan Scott 18 Sep '23

18 Sep '23

Regarding the first question ("Is this restriction *really* necessary?"), I think the answer is likely "no", at least for most data family instances. This discussion [1] is the most up-to-date reference on the history and motivations behind the current restriction. In that discussion, it is hypothesized that data family instances whose data constructors do not use any constraints could be promoted without needing to rethink how Core works. (If I understand correctly, all of your data family instances fall into this simple subset.) This discussion could provide a template for a GHC proposal that proposes to allow this feature. Best, Ryan ----- [1] https://github.com/ghc-proposals/ghc-proposals/discussions/456

2 1

Limitations of generalization of type constructors
by Tom Ellis 18 Sep '23

18 Sep '23

Hello Cafe, Generalization of types in type constructors behaves strangely compared to the same behaviour at the term level. I was wondering whether this is expected, whether it's a known issue that's due to be resolved, or is a known issue that can't be resolved for some technical reason. This mail is a literate Haskell file. > {-# LANGUAGE DataKinds #-} > {-# LANGUAGE PolyKinds #-} > {-# LANGUAGE RankNTypes #-} > {-# LANGUAGE StandaloneKindSignatures #-} > {-# LANGUAGE TypeFamilies #-} > > {-# OPTIONS_GHC -Wall #-} > {-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-} > > import Prelude hiding (const) > import Data.Kind (Type) `f` takes an argument of polymorphic type > f :: (forall (z :: Type). Maybe z -> Int) -> Int > f k = k (Just True) `c1` is an argument that will fit there. Its type matches exactly. > c1 :: forall (z :: Type). Maybe z -> Int > c1 _ = 0 > > fc1 :: Int > fc1 = f c1 `c2` will fit there but its type doesn't match exactly. `z` will have to be substituted with `Maybe z`, obtaining the type forall (z :: Type). Maybe z -> Int which does fit exactly. > c2 :: forall (z :: Type). z -> Int > c2 _ = 0 > > fc2 :: Int > fc2 = f c2 `const` will fit there, once `z` is substituted with `Maybe z`, the `Int` argument applied and the quantifer moved, obtaining the type forall (z :: Type). Maybe z -> Int which does fit exactly. > const :: forall (z :: Type). Int -> z -> Int > const x _ = x > > fc3 :: Int > fc3 = f (const 0) The story for type constructors is not so pleasant. I can define an analogue of `f` on the type level: > type F :: (forall (z :: Type). Maybe z -> Type) -> Type > newtype F k = F (k (Just Bool)) and the analogue of `c1` fits exactly: > type C1 :: forall (z :: Type). Maybe z -> Type > data C1 m = C1 > > type FC1 :: Type > type FC1 = F C1 but the analogue of `c2` does not: > type C2 :: forall (z :: Type). z -> Type > data C2 m = C2 > > -- Occurs check: cannot construct the infinite kind: z ~ Maybe z > -- type FC2 :: Type > -- type FC2 = F C2 nor does the analogue of `const`: > type Const :: forall (z :: Type). Type -> Maybe z -> Type > newtype Const z a = Const z > > -- • Expected kind ‘forall z. Maybe z -> *’, > -- but ‘Const ()’ has kind ‘Maybe a0 -> *’ > -- type FC3 :: Type > -- type FC3 = F (Const ()) To get the analogue of `const` we have to be much more specific: > type OtherConst :: Type -> forall (z :: Type). Maybe z -> Type > newtype OtherConst z b = OtherConst z > > type FC4 :: Type > type FC4 = F (OtherConst ()) This is rather unfortunate because it limits generic programming at the type level!

1 0

Why can't I promote data family constructors, and what to do instead?
by Tom Ellis 16 Sep '23

16 Sep '23

Hello Cafe, I'm confused why I can't promote data family constructors, and what I should do instead. This message is a literate Haskell file. > {-# LANGUAGE DataKinds #-} > {-# LANGUAGE StandaloneKindSignatures #-} > {-# LANGUAGE TypeFamilies #-} I can promote constructors of normal data types nicely, here CT1 is promoted > data T = CT1 Char > type PT1 = CT1 'x' Suppose I want to promote constructors of a "non uniform" data definition, that is one where the structure of the type depends on a type argument, In Haskell that means a GADT, type family or data family. For my purposes a type family is unsuitable. I need to be able to reference it unsaturated. A GADT is also unsuitable because it introduces extra runtime tags that I don't want. But nor do data families work because their constructors can't be promoted. > data family DF a > newtype instance DF Int = CDFInt1 Char > data instance DF Bool = CDFBool1 | CDFBool2 > > -- • Data constructor ‘CDFInt1’ cannot be used here > -- (it comes from a data family instance) > -- type PDF = CDFInt1 'x' The GHC users guide says Data family instance constructors cannot be promoted at the moment. GHC’s type theory just isn’t up to the task of promoting data families, which requires full dependent types. https://downloads.haskell.org/ghc/9.6.2/docs/users_guide/exts/data_kinds.ht… I'm puzzled about why I can't do that. I can do this > newtype DFInt = CDFInt1' Char > data DFBool = CDFBool1' | CDFBool2' > type family TF a > type instance TF Int = DFInt > type instance TF Bool = DFBool > type PNF1 :: TF Int > type PNF1 = CDFInt1' 'x' which I said above is unsuitable because I can't refer to `TF` unsaturated. But I can apply a standard trick of wrapping a type family in a newtype: > newtype NF a = CNF (TF a) > type PNF :: NF Int > type PNF = CNF (CDFInt1' 'x') Problem solved! But this goes all round the houses. What a mess! The data family version would be much neater if it worked. I have two questions: 1. Is this restriction *really* necessary? I'm surprised that GHC can't cope with promoting constructors of data families given that it is straightforward to simulate the desired behaviour with type families and a newtype. 2. Is my encoding the simplest that I can achieve? Note that the following GADT does *not* work because `GDFInt` has an unnecessary tag. > data GF a where > GDFInt :: Char -> GF Int > GDFBool1 :: GF Bool > GDFBool2 :: GF Bool

1 0

[ANN] Jacinda 2.0.1.0
by Vanessa McHale 13 Sep '23

13 Sep '23

Hello all, I have released another iteration of Jacinda, a text-processing language that lets you filter (fits in with sed + awk), handy on Unix! I’ve rewritten the backend so it should have far fewer bugs! https://github.com/vmchale/jacinda/releases/tag/2.0.1.0 Cheers, Vanessa McHale

1 0

ANN: shelltestrunner 1.10
by Simon Michael 12 Sep '23

12 Sep '23

I'm pleased to announce shelltestrunner 1.10 ! shelltestrunner (executable: `shelltest`) is a portable, GPLv3+ command-line tool for testing command-line programs or shell commands. It reads simple test specifications defining a command to run, some input, and the expected output, stderr, and exit status. It can run tests in parallel, selectively, with a timeout, in color, etc. The last release was 1.9, in 2018. The 1.10 release has been overdue; it brings some useful improvements, notably --print mode (with which you can convert old format 1 tests to the cleaner, recommended format 3), and precise line number reporting (to quickly locate the failing test). User-visible changes in 1.10 (2023-09-12): * GHC 9.6 compatibility (Andreas Abel) * Add --print for printing tests and/or converting file format (#24, Jakob Schöttl) * Add --shell option to select shell (#17, FC Stegerman) * Fix format1's handling of angle brackets in test data (#16) * Print test line number on failure (#14, Taavi Väljaots) * Add -p short flag for --precise * -h means --help, not --hide-successes * Clarify 300 char regex limit message Other changes: * Set up CI testing (#18 FC Stegerman, Simon Michael) * Improve bash-related tests (#20, FC Stegerman, Simon Michael) * Improved tests Thanks to release contributors: Jakob Schöttl, Taavi Väljaots, Felix C. Stegerman, and Andreas Abel. Install: $ stack install shelltestrunner-1.10 or: $ cabal update && cabal install shelltestrunner-1.10 Home: https://github.com/simonmichael/shelltestrunner

1 0

SPLASH 2023 Call for Participation
by Alcides Fonseca 12 Sep '23

12 Sep '23

====================================================================== Call For Participation ACM Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH'23) October 22-27, 2023, Cascais, Portugal https://2023.splashcon.org/ Follow us on Twitter @splashcon ====================================================================== The ACM SIGPLAN conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH) embraces all aspects of software construction and delivery to make it the premier conference at the intersection of programming, languages, and software engineering. ====================================================================== # Participation ====================================================================== The registration information, including the link to registration form is available at https://2023.splashcon.org/attending/Registration ====================================================================== # List of Keynotes/Invited Talks ====================================================================== SPLASH will feature three keynotes: Amal Ahmed, Northeastern University, USA Dimitrios Vytiniotis, DeepMind, UK Joe Hellerstein, UC Berkeley, USA SPLASH co-located events include a number of speakers: Andreas Rossberg, Independent, Germany (MPLR) Manuel Hermenegildo, IMDEA, Spain (LOPSTR) Maribel Fernández, King's College London, UK (PPDP+LOPSTR) Delia Kesner, Université Paris Cité, France (PPDP) Daniel Kaestner, AbsInt, Germany (SAS) Gagandeep Singh, University of Illinois Urbana-Champaign, USA (SAS) Bor-Yuh Evan Chang, University of Colorado Boulder & Amazon, USA (SAS) Loris D’Antoni, University of Wisconsin, Madison, USA (SAS) ====================================================================== # List of Events ====================================================================== ** OOPSLA Research Papers ** Papers that address any aspect of software development are welcome, including requirements, modelling, prototyping, design, implementation, generation, analysis, verification, testing, evaluation, maintenance, reuse, replacement, and retirement of software systems. Papers may address these topics in a variety of ways, including new tools (such as languages, program analyses, and runtime systems), new techniques (such as methodologies, design processes, code organization approaches, and management techniques), and new evaluations (such as formalisms and proofs, corpora analyses, user studies, and surveys). ** Onward! Research Papers ** Onward! is a premier multidisciplinary conference focused on everything to do with programming and software: including processes, methods, languages, communities, and applications. Onward! is more radical, more visionary, and more open than other conferences to ideas that are well-argued but not yet proven. We welcome different ways of thinking about, approaching, and reporting on programming language and software engineering research. ** Onward! Essays ** Onward! Essays conference is looking for clear and compelling pieces of writing about topics important to the software community construed broadly. An essay can be an exploration of a topic, its impact, or the circumstances of its creation; it can present a personal view of what is, explore a terrain, or lead the reader in an act of discovery; it can be a philosophical digression or a deep analysis. It can describe a personal journey, perhaps that by which the author reached an understanding of such a topic. The subject area should be interpreted broadly and can include the relationship of software to human endeavours, or its philosophical, sociological, psychological, historical, or anthropological underpinnings. ** PLMW@SPLASH ** The SPLASH 2023 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. ====================================================================== ** 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. **** 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. **** 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. **** 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. **** VMIL **** The concept of Virtual Machines is pervasive in the design and implementation of programming systems. Virtual Machines and the languages they implement are crucial in the specification, implementation and/or user-facing deployment of most programming technologies. The VMIL workshop is a forum for researchers and cutting-edge practitioners in language virtual machines, the intermediate languages they use, and related issues. The workshop is intended to be welcoming to a wide range of topics and perspectives, covering all areas relevant to the workshop’s theme. ====================================================================== ** SPLASH 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. SPLASH posters cover 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. ====================================================================== ** Doctoral Symposium ** ====================================================================== The SPLASH Doctoral Symposium provides students with useful guidance for completing their dissertation research and beginning their research careers. The symposium will provide an interactive forum fordoctoral students who have progressed far enough in their research to have a structured proposal, but will not be defending their dissertation in the next 12 months. ====================================================================== ** Student Research Competition ** ====================================================================== The ACM Student Research Competition (SRC), sponsored by Microsoft Research, 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. ====================================================================== ** SPLASH-E ** ====================================================================== SPLASH-E is a forum for educators to make connections between programming languages research and the ways we educate computer science students. We invite work that could improve or inform computer science educators, especially work that connects with introductory computer science courses, programming languages, compilers, software engineering, and other SPLASH-related topics. Educational tools, experience reports, and new curricula are all welcome. ====================================================================== *** 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. **** 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. **** Logic-based Program Synthesis and Transformation (LOPSTR)**** The aim of the LOPSTR series is to stimulate and promote international research and collaboration on logic-based program development. LOPSTR is open to contributions in logic-based program development in any language paradigm. LOPSTR has a reputation for being a lively, friendly forum for presenting and discussing work in progress. **** 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). **** Principles and Practice of Declarative Programming (PPDP) **** PPDP aims to provide a forum that brings together researchers from the declarative programming communities, including those working in the logic, constraint and functional programming paradigms, but also embracing a variety of other paradigms such as visual programming, executable specification languages, database languages, AI languages and knowledge representation languages used, for example, in the semantic web. The goal is to stimulate research in the use of logical formalisms and methods for specifying, performing, and analysing computations, including mechanisms for mobility, modularity, concurrency, object-orientation, security, and static analysis. Papers related to the use of declarative paradigms and tools in industry and education are especially solicited. **** Static Analysis Symposium (SAS) **** Static Analysis is widely recognized as a fundamental tool for program verification, bug detection, compiler optimization, program understanding, and software maintenance. The series of Static Analysis Symposia has served as the primary venue for the presentation of theoretical, practical, and application advances in the area. ====================================================================== # Organizing Committee SPLASH 2023: ====================================================================== 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) Video Co-Chair: John Hui (Columbia University) 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: Diana Costa (University of Lisbon) SIGPLAN Conference Manager: Neringa Young ======================================================================

1 0

OOPSLA 2024: Round 1 Call for Papers
by Umar Farooq 12 Sep '23

12 Sep '23

======================================================================== PACMPL Issue OOPSLA 2024 Call for Papers OOPSLA 2024 will be held as part of The ACM Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH'24) October 20-25, 2024, Pasadena, California, United States https://2024.splashcon.org/track/splash-2024-oopsla ======================================================================== ### Important dates #### ROUND 1: Submission Deadline: Fri Oct 20, 2023 Author Response: Mon Dec 11 - Wed Dec 13, 2023 Author Notification: Fri Dec 22, 2023 Artifact Submission: Fri Jan 5, 2024 Artifact kick-tires: Sat Jan 6 - Fri Jan 19, 2024 Submission of Revisions: Sun Feb 11, 2024 Author Notification of Revisions: Sat Feb 24, 2024 Artifact Notification: Fri Mar 1, 2024 Camera Ready: Fri Mar 8, 2024 #### ROUND 2: Submission Deadline: Fri Apr 5, 2024 Author Response: Mon Jun 3 - Wed Jun 5, 2024 Author Notification: Fri Jun 21, 2024 Artifact Submission: Fri Jul 5, 2024 Artifact kick-tires: Sat Jul 6 - Fri Jul 19, 2024 Submission of Revisions: Sun Aug 4, 2024 Author Notification of Revisions: Sun Aug 18, 2024 Artifact Notification: Fri Aug 23, 2024 Camera Ready: Sun Sep 1, 2024 Papers accepted at either of the rounds will be published in the 2024 volume of PACMPL(OOPSLA) and invited to be presented at the SPLASH conference in October 2024. ### Scope The OOPSLA issue of the Proceedings of the ACM on Programming Languages (PACMPL) welcomes papers focusing on all practical and theoretical investigations of programming languages, systems and environments. Papers may target any stage of software development, including requirements, modelling, prototyping, design, implementation, generation, analysis, verification, testing, evaluation, maintenance, and reuse of software systems. Contributions may include the development of new tools, techniques, principles, and evaluations. #### Review Process PACMPL(OOPSLA) has two rounds of reviewing with submission deadlines around October and April each year. As you submit your paper you will receive around three reviews and an opportunity to provide an author response that will be read and addressed by the reviewers in the final decision outcome summary. There are 5 possible outcomes at the end of the round: *Accept*: Your paper will appear in the upcoming volume of PACMPL (OOPSLA). *Conditional Accept*: You will receive a list of required revisions that you will need to address. You must submit a revised paper, a clear explanation of how your revision addresses these comments, and "if possible" a diff of the PDF as supplementary material. Assuming you meet the listed requirements, after further review by the same reviewers, your paper will very likely be accepted. This process *has to be completed within two months of the initial decision* for the paper to be accepted, so we encourage timely turnaround in case revisions take more than one cycle to be accepted. *Minor Revision*: The reviewers have concerns that go beyond what can be enumerated in a list. Therefore, while you may receive a list of revisions suggested by the reviewers, this will not necessarily be comprehensive. You will have the opportunity to resubmit your revised paper and have it re-reviewed by the same reviewers, which may or may not result in your paper's acceptance. When you resubmit, you should clearly explain how the revisions address the comments of the reviewers, by including a document describing the changes and "if possible" a diff of the PDF as supplementary material. This process *has to be completed within two months of the initial decision* for the paper to be accepted in the current round, so we encourage timely turnaround in case revisions take more than one cycle to be accepted. *Major Revision*: You will receive a list of revisions suggested by the reviewers. Papers in this category are *invited to submit a revision to the next round of submissions* with a specific set of expectations to be met. When you resubmit, you should clearly explain how the revisions address the comments of the reviewers, by including a document describing the changes and "if possible" a diff of the PDF as supplementary material. The revised paper will be re-evaluated in the next round. Resubmitted papers will retain the same reviewers throughout the process to the extent possible. *Reject*: Rejected papers will not be included in the upcoming volume of PACMPL(OOPSLA). Papers in this category are not guaranteed a review if resubmitted less than one year from the date of the original submission. A paper will be judged to be a resubmission if it is substantially similar to the original submission. The Chairs will decide whether or not a paper is a resubmission of the same work. ### Submissions Submitted papers must be at most **23 pages** in 10 point font. There is no page limit on references. No appendices are allowed on the main paper, instead authors can upload supplementary material with no page or content restrictions, but reviewers may choose to ignore it. Submissions must adhere to the "ACM Small" template available from [the ACM](http://www.acm.org/publications/authors/submissions). Papers are expected to use author-year citations. Author-year citations may be used as either a noun phrase, such as "The lambda calculus was originally conceived by Church (1932)", or a parenthetic phase, such as "The lambda calculus (Church 1932) was intended as a foundation for mathematics". PACMPL uses double-blind reviewing. Authors' identities are only revealed if a paper is accepted. Papers must 1. omit author names and institutions, 2. use the third person when referencing your work, 3. anonymise supplementary material. Nothing should be done in the name of anonymity that weakens the submission; see the DBR FAQ. When in doubt, contact the Review Committee Chairs. Papers must describe unpublished work that is not currently submitted for publication elsewhere as described by [SIGPLAN's Republication Policy](http://www.sigplan.org/Resources/Policies/Republication). Submitters should also be aware of [ACM's Policy and Procedures on Plagiarism](http://www.acm.org/publications/policies/plagiarism_policy). Submissions are expected to comply with the [ACM Policies for Authorship](https://www.acm.org/publications/authors/information-for-author…. #### Artifacts Authors should indicate with their initial submission if an artifact exists, describe its nature and limitations, and indicate if it will be submitted for evaluation. Accepted papers that fail to provide an artifact will be requested to explain the reason they cannot support replication. It is understood that some papers have no artifacts. Please note that the artifact submission deadline will be following closely the paper submission deadline so make sure you check the Artifact Call as soon as you submit your paper to PACMPL(OOPSLA). ##### Data-Availability Statement To help readers find data and software, OOPSLA recommends adding a section just before the references titled Data-Availability Statement. If the paper has an artifact, cite it here. If there is no artifact, this section can explain how to obtain relevant code. The statement does not count toward the OOPSLA 2024 page limit. It may be included in the submitted paper; in fact we encourage this, even if the DOI is not ready yet. Example: \section{Conclusion} .... \section*{Data-Availability Statement} The software that supports~\cref{s:design,s:evaluation} is available on Software Heritage~\cite{artifact-swh} and Zenodo~\cite{artifact-doi}. \begin{acks} .... #### Expert PC Members During the submission, we will ask you to list up to 3 non-conflicted PC members who you think are experts on the topic of this submission, starting with the most expert. This list will not be used as an input during the paper assignment and it will not be visible to the PC. It may be used by the PC Chair and Associate Chairs for advice on external experts if the paper lacks expert reviews. ### Publication PACMPL is a Gold Open Access journal, all papers will be freely available to the public. Authors can voluntarily cover the article processing charge ($400 USD), but payment is not required. The official publication date is the date the journal is made available in the ACM Digital Library. The journal issue and associated papers may be published up to two weeks prior to the first day of the conference. The official publication date affects the deadline for any patent filings related to published work. By submitting your article to an ACM Publication, you are acknowledging that you and your co-authors are subject to all [ACM Publications Policies](https://www.acm.org/publications/policies), including ACM’s [new Publications Policy on Research Involving Human Participants and Subjects](https://www.acm.org/publications/policies/research-involving-huma…. Alleged violations of this policy or an ACM Publications Policy will be investigated by ACM and may result in a full retraction of your paper, in addition to other potential penalties, as per ACM Publications Policy. Please ensure that you and your co-authors obtain [an ORCID ID](https://orcid.org/register), so you can complete the publishing process for your accepted paper. ACM has been involved in ORCID from the start and we have recently made a [commitment to collect ORCID IDs from all of our published authors](https://authors.acm.org/author-resources/orcid-faqs). We are committed to improving author discoverability, ensuring proper attribution and contributing to ongoing community efforts around name normalization; your ORCID ID will help in these efforts. The ACM Publications Board has recently updated the ACM Authorship Policy in several ways: - Addressing the use of generative AI systems in the publications process - Clarifying criteria for authorship and the responsibilities of authors - Defining prohibited behaviour, such as gift, ghost, or purchased authorship - Providing a linked FAQ explaining the rationale for the policy and providing additional details You can find the updated policy here: [https://www.acm.org/publications/policies/new-acm-policy-on-authorship](htt… ##### Review Committee Review Committee Chairs: Alex Potanin, Australian National University, Australia Bor-Yuh Evan Chang, University of Colorado Boulder, USA Review Committee Associate Chairs: Anders Møller, Aahrus University, Denmark Lingming Zhang, UIUC, USA Review Committee: Aleksandar Nanevski, IMDEA Software Institute, Spain Alex Summers, University of British Columbia, Canada Alexandra Bugariu, ETH Zurich, Switzerland Ana Milanova, Rensselaer Polytechnic Institute, USA Andreas Zeller, CISPA Helmholtz Center for Information Security, Germany Anitha Gollamudi, UMass, USA Ankush Desai, AWS, USA Ashish Tiwari, Microsoft Research, USA Ben Hermann, TU Dortmund, Germany Ben Titzer, CMU, USA Benjamin Delaware, Purdue University, USA Bernardo Toninho, Universidade Nova de Lisboa, Portugal Bruno C. d. S. Oliveira, U. Hong Kong, Hong Kong Burcu Kulahcioglu Ozkan, Delft University of Technology, The Netherlands Casper Bach Poulsen, Delft University of Technology, Netherlands Colin Gordon, Drexel University, USA Corina Pasarenau, NASA, USA Cyrus Omar, University of Michigan, USA Damien Zufferey, Sonar Source, Switzerland Dana Drachsler Cohen, Technion, Israel David Darais, Galois, USA David Pearce, ConsenSys, New Zealand Di Wang, Peking University, China Emma Söderberg, Lund University, Sweden Emma Tosch, Northeastern University, USA Fabian Muehlboeck, Australian National University, Australia Fei He, Tsinghua University, China Filip Niksic, Google, USA Fredrik Kjolstad, Stanford University, USA Guido Salvaneschi, University of St. Gallen, Switzerland Hila Peleg, Technion, Israel Jiasi Shen, The Hong Kong University of Science and Technology, China (Hong Kong) Jonathan Bell, Northeastern University, USA Jonathan Brachthäuser, University of Tübingen, Germany Joseph Tassarotti, New York University, USA Justin Hsu, Cornell University, USA Karine Even-Mendoza, King's College London, UK Kenji Maillard, Inria Rennes, France Matthew Flatt, U. Utah, USA Matthew Parkinson, Microsoft, UK Max Schaefer, GitHub, UK Michael Coblenz, UCSD, USA Milos Gligoric, UT Austin, USA Minseok Jeon, Korea University, Korea Mohamed Faouzi Atig, Uppsala University, Sweden Owolabi Legunsen, Cornell University, USA Pamela Zave, AT&T Laboratories, USA Pavel Panchekha, University of Utah, USA Rahul Gopinath, University of Sydney, Australia Rajiv Gupta, UC Riverside, USA Saman Amarasinghe, MIT, USA Santosh Pande, Georgia Institute of Technology, USA Sean Treichler, NVIDIA, USA Shachar Itzhaky, Technion, Israel Shaz Qadeer, Facebook, USA Sheng Chen, University of Louisiana at Lafayette, USA Shigeru Chiba, University of Tokyo, Japan Shriram Krishnamurthi, Brown University, USA Sreepathi Pai, University of Rochester, USA Stefan Brunthaler, University of the Federal Armed Forces in Munchen, Germany Steve Blackburn, Google, Australia Subhajit Roy, IIT Kanpur, India Sukyoung Ryu, KAIST, Korea Swarnendu Biswas, IIT Kanpur, India Thanh Vu Nguyen, George Mason University, USA Tiark Rompf, Purdue, USA Tien Nguyen, University of Texas at Dallas, USA Tomas Petricek, Charles University, Czech Republic Umut Acar, CMU, USA Wei Le, Iowa State, USA Wei Zhang , Meta, USA Xiaokang Qiu, Purdue University, USA Yingfei Xiong, Peking University, China Yizhou Zhang, University of Waterloo, Canada Youyou Cong, Tokyo Institute of Technology, Japan Yu David Liu, Binghamton, USA Yu Feng, UCSB, USA Yuepeng Wang, Simon Fraser University, Canada ##### Artifact Evaluation Committee Artifact Evaluation Committee Chairs: Guillaume Baudart, Inria - École normale supérieure, France Sankha Narayan Guria, University of Kansas, USA

1 0

heterogeneous container smart constructor question
by Zoran Bošnjak 05 Sep '23

05 Sep '23

Dear haskellers, I am trying to add some type safety to the program in the following situation: There are some distinct 'Item t' types which come in groups. That is: 'EList' container can contain either: - items 0,1 - items 0,1,2,3 - items 0,1,2,3,4,5,6 All other combinations (like items 0,1,2) are invalid and shall be rejected by compiler. The 'EList' implementation (see below) seems to have this property. In addition, I would like to define a smart constructor (mkEList), to simplify EList construction from some linear (no groups) IList type. In other words, mkEList shall slice IList to proper groups. I am aware that I need to use a type class / type families for this. I have tried several approaches, but ghc was not happy with any. What is the correct implementation of mkEList? Here is a sample code and the intended usage: -- (sample build-test.hs) import GHC.TypeLits data Item (t :: Nat) = Item -- List/group of items data IList (ts :: [Nat]) where INil :: IList '[] ICons :: Item t -> IList ts -> IList (t ': ts) nil :: IList '[] nil = INil infixr 5 &: (&:) :: Item t -> IList ts -> IList (t : ts) (&:) = ICons -- Extended list of groups data EList (ts :: [Nat]) (tss :: [[Nat]]) where EList :: IList ts1 -> Maybe (EList ts2 tss) -> EList ts1 (ts2 ': tss) instance Eq (EList ts tss) -- Manual test type T1 = '[0, 1] type T2 = '[ '[2, 3], '[4, 5, 6], '[] ] test1 :: EList T1 T2 test1 = EList (Item @0 &: Item @1 &: nil) Nothing test2 :: EList T1 T2 test2 = EList (Item @0 &: Item @1 &: nil) (Just (EList (Item @2 &: Item @3 &: nil) Nothing)) test3 :: EList T1 T2 test3 = EList (Item @0 &: Item @1 &: nil) (Just (EList (Item @2 &: Item @3 &: nil) (Just (EList (Item @4 &: Item @5 &: Item @6 &: nil) Nothing)))) -- Intended usage -- | Helper function or class method :: IList ? -> EList ? ? mkEList :: a mkEList = undefined el1 :: EList T1 T2 el1 = mkEList ( Item @0 &: Item @1 &: nil) el2 :: EList T1 T2 el2 = mkEList ( Item @0 &: Item @1 &: Item @2 &: Item @3 &: nil) el3 :: EList T1 T2 el3 = mkEList ( Item @0 &: Item @1 &: Item @2 &: Item @3 &: Item @4 &: Item @5 &: Item @6 &: nil) check :: Bool -- expecting True check = and [el1 == test1, el2 == test2, el3 == test3] -- (end of sample) regards, Zoran

3 4

The Haskell Foundation is seeking a new Executive Director
by David Christiansen 05 Sep '23

05 Sep '23

Dear Cafe, I just realized that we didn't yet post this here - apologies! I'll be stopping as ED of the Haskell Foundation at the end of the month, because I got an offer to go back to software development and work on a combination of technologies that I personally find extremely interesting (dependent types, procedural hygienic macros, language embedding, software verification, documentation and tools). It wasn't an easy decision to make, but I won't be disappearing from the world of pure functional programming. This means we need a new ED! You can see details here: https://haskell.foundation/careers/executive-director.html Every application received by the 29th will receive full consideration, but the board will continue taking applications until the new ED has been found. Until 22 September, I have time reserved to meet with people who are interested, but unsure about whether the role is a good fit. I myself have had these concerns - it was my first job not doing research or software development since I was 23 years old, after all. I'm happy to have an honest discussion about the job, how I did it, how someone else with different strengths might do it, what my daily life is like and the constraints that give rise to that, and so forth. Just let me know if you're interested. My canonical farewell post is here: https://discourse.haskell.org/t/an-opportunity-that-i-couldnt-pass-up/7485 Thanks for your support! I'll see you around. David

1 0

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

04 Sep '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 *** If you are attending the ICFP conference in Seattle this week, please feel free to speak with Nicolas Wu if you have any questions about submitting for the special issue *** 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

ANN: hledger 1.31
by Simon Michael 03 Sep '23

03 Sep '23

I'm pleased to announce hledger 1.31 ! Highlights: - In conversion transactions, costs and equity postings are matched more tolerantly. - The `print` command now more closely replicates the original journal amount styles, which is helpful when round-tripping / cleaning up journal files. - Multi-pivot - the --pivot option can now construct account names from multiple fields. Thank you release contributors Dmitry Astapov, Eric Mertens, Jay Neubrand, and Jonathan Dowland. - https://github.com/simonmichael/hledger/releases/1.31 - https://hledger.org/release-notes.html#hledger-1-31 - 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

OAuth on gitlab.haskell.org
by Julian Brunner 28 Aug '23

28 Aug '23

Hello, I last used gitlab.haskell.org in 2022 via OAuth on my GitHub account. However, this seems to no longer be an option. The account itself (https://gitlab.haskell.org/julianbrunner) seems to still exist, but I am unable to log in or request a password reset. I could not find any way to contact anyone on gitlab.haskell.org or any information on the removal of the OAuth option. Does anyone know how I can get my account back or who I should contact to get this sorted out? Cheers, Julian

3 4

debugging <<loop>> exception
by Dennis Raddle 28 Aug '23

28 Aug '23

I'm getting Exception: <<loop>>. It doesn't print the line number. When I load the program into ghci, it still doesn't print the line number. When I trace the program in ghci it never gets to the point of emitting the exception. I set up my program in stack. I tried both "stack ghci" and just "ghci".. the latter to make sure it wasn't using any compiled code (at least in my own code). If it doesn't print a line number does this mean it's happening in compiled code? Any ideas how I can go about debugging this?

3 3

Munich Haskell Meeting, 2023-08-30 @ 19:30
by Leah Neukirchen 26 Aug '23

26 Aug '23

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Wednesday, August 30 at Augustiner-Kurgarten (De-la-Paz-Straße 10, 80639 München) at 19h30. Different location as Rumpler is on summer holidays! 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/xYna3xETL2UACtzT Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

IOSim on Hackage
by coot＠coot.me 26 Aug '23

26 Aug '23

Hello dear Haskell-Cafe, I realised that I haven't shared here that we (the networking team of IOG) released io-sim on Hackage. We found and fixed countless bugs thanks to it, including some concurrent ones. Here's a blog post which I wrote some time ago: https://engineering.iog.io/2023-04-14-io-sim-annoucement https://hackage.haskell.org/package/io-sim https://hackage.haskell.org/package/io-classes Cheers, Marcin Szamotulski

2 5

[ANNOUNCE] GHC 9.4.7 is now available
by Zubin Duggal 26 Aug '23

26 Aug '23

The GHC developers are happy to announce the availability of GHC 9.4.7. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.4.7 The GHC developers are happy to announce the availability of GHC 9.4.7. Binary distributions, source distributions, and documentation are available at [downloads.haskell.org](https://downloads.haskell.org/ghc/9.4.7). This release is primarily a bugfix release addressing some issues found in 9.4.6. These include: * A bump to bytestring-0.11.5.2 allowing GHC to be bootstrapped on systems where the bootstrap compiler is built with the `pthread_condattr_setclock` symbol available (#23789). * A number of bug fixes for scoping bugs in the specialiser, preventing simplifier panics (#21391, #21689, #21828, #23762). * Distributing dynamically linked alpine bindists (#23349, #23828). * A bug fix for the release notes syntax, allowing them to built on systems with older python and sphinx versions (#23807, #23818). * ... and a few more. See the [release notes] for a full accounting. We would like to thank Microsoft Azure, GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, 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, - Zubin [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new [release notes]: https://downloads.haskell.org/~ghc/9.4.7/docs/users_guide/9.4.7-notes.html

1 0

[ANNOUNCE] GHC 9.4.6 is now available
by Ben Gamari 26 Aug '23

26 Aug '23

The GHC developers are happy to announce the availability of GHC 9.4.6. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.4.6 This release is primarily a bugfix release addressing some issues found in 9.4.6. These include: * Many bug fixes for the simplifier, preventing compiler panics, loops and incorrect code generation (#22761, #22549, #23208, #22761, #22272, #23146, #23012, #22547). * Bug fixes for the typechecker involving newtype family instances, making type equalities more robust and bugs having to do with defaulting representation polymorphic type variables (#23329, #23333, #23143, #23154, #23176). * Some bug fixes for code generation, particularly on the aarch64 backend, including adding more memory barriers for array read operations (#23541, #23749). * Some bug fixes for windows builds, ensuring the reliablility of IO manager shutdown and a bug fix for the RTS linker on windows (#23691, #22941). * A bug fix for the non-moving GC ensuring mutator allocations are properly accounted for (#23312). * A bug fix preventing some segfaults by ensuring that pinned allocations respect block size (#23400). * Many bug fixes for the bytecode interpreter, allowing a greater subset of the language to be interpreted (#22376, #22840, #22051, #21945, #23068, #22958). * ... and a few more. See the [release notes] for a full accounting. As some of the fixed issues do affect correctness users are encouraged to upgrade promptly. We would like to thank Microsoft Azure, GitHub, IOG, the Zw3rk stake pool, Well-Typed, Tweag I/O, Serokell, Equinix, SimSpace, 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, - Zubin & Ben [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new [release notes]: https://downloads.haskell.org/~ghc/9.4.6/docs/users_guide/9.4.6-notes.html

2 1