- Haskell-Cafe - Haskell.org

Retro/indie Haskell to appreciate
by Vanessa McHale 13 Apr '22

13 Apr '22

I’m looking to appreciate “retro” Haskell projects, things from before stabilization/company use. Such as: fgl https://web.engr.oregonstate.edu/~erwig/fgl/haskell/ <https://web.engr.oregonstate.edu/~erwig/fgl/haskell/> WWWBrowser https://cth.altocumulus.org/~hallgren/wwwbrowser.html <https://cth.altocumulus.org/~hallgren/wwwbrowser.html> Balsa/Teak (languages) http://apt.cs.manchester.ac.uk/projects/tools/balsa/ <http://apt.cs.manchester.ac.uk/projects/tools/balsa/> BlueSpec compiler https://github.com/B-Lang-org/bsc <https://github.com/B-Lang-org/bsc> The CABAL spec (Common Architecture for Building Applications and Tools) https://www.haskell.org/cabal/proposal/index.html <https://www.haskell.org/cabal/proposal/index.html> Frag (that one Haskell game) https://wiki.haskell.org/Frag Hugs string extensions https://www.haskell.org/hugs/pages/users_guide/here-documents.html <https://www.haskell.org/hugs/pages/users_guide/here-documents.html> I guess darcs/c2hs/happy/alex count, they have history! Bonus points for Makefiles to build the project Professor-HTML project page Hugs support Haskell 1.4 etc. support

9 10

The planned monomorphisation of Data.List
by Tom Ellis 13 Apr '22

13 Apr '22

There is a plan to monomorphise the contents of Data.List. I have written up an executive summary on the GitHub thread where it is being discussed. If you have an opinion that you would like to be taken into account then please leave a comment on that GitHub thread. https://github.com/haskell/core-libraries-committee/issues/22#issuecomment-…

1 0

Re: [Haskell-cafe] ANN: haskell for mathematicians
by Olaf Klinke 10 Apr '22

10 Apr '22

>Dear Olaf, > >On Sat 09 Apr 2022 10:45:56 PM GMT, Olaf Klinke wrote: >> my monograph "Haskell for Mathematicians" has found a home online: >> https://hub.darcs.net/olf/haskell_for_mathematicians > >I just had a first look, your monograph looks awesome! Thank you for >sharing! > >In haskell_for_mathematicians.tex, you mention as a further idea that >Hask is like a Heyting algebra. Could you elaborate on that point? Are >you thinking of types as propositions here? > >Cheers, >Ingo Hi Ingo, Types as propositions is dealt with in haskell_for_logicians.lhs. Hask has an arrow that is a right adjoint, just like a Heyting algebra. It is less clear, however, whether the the arrow gives rise to a partial order as it does in Heyting algebras. I am interested in the complete Heyting algebras, a.k.a. frames a.k.a. locales. Many concepts in point-free topology heavily rely on partial orders and lattice theory, so without a good analogue I would not dare declare a similarity. For example, in a Heyting algebra x <= y iff x -> y equals the top element. But then, what is the top element of Hask? Do we declare x <= y if x -> y is inhabited? That seems to collapse all inhabited types. In a future chapter I would like to tell a story around this: In point-free topology (locale theory), there are several inter-definable concepts of sub-object. One of them is a "nucleus", that is an endo-function j with the following properties. x <= y implies j(x) <= j(y) (j is a functor) x <= j(x) (return :: x -> j x) j(j(x)) <= j(x) (join :: j (j x) -> j x) j(x) /\ j(y) <= j(x /\ y) (liftM2 (,) :: j x -> j y -> j (x,y)) In other words: sub-objects of point-free spaces are (strong) monads. In that respect, every monad j is a sub-object of Hask, and indeed it is: It defines the sub-category (Kleisli j). There are more analogues: The identity function is a nucleus and corresponds to the greatest sub-object, and in Hask (Kleisli Identity) is the largest Kleisli category. Nuclei can not be combined easily, and neither can monads. Another interesting question is: What are the "points" of Hask? A point of a locale is a mapping from opens (types of Hask) to Bool that preserves finite products and arbitrary coproducts, where True is considered as the empty product and False as the empty coproduct. How many of such mappings can be defined in Haskell? How would we implement them? As a class? Type family? GADT? The funny thing about locales is that one can have few or no points but still a rich supply of sub-objects. Olaf

2 1

ANN: haskell for mathematicians
by Olaf Klinke 10 Apr '22

10 Apr '22

Dear Café, my monograph "Haskell for Mathematicians" has found a home online: https://hub.darcs.net/olf/haskell_for_mathematicians The intended audience of this course is mathematicians. While there are many (and excellent) introductions and complete books on Haskell available, most of them target programmers. But Haskell, despite being practically useful, is very good at modelling certain branches of mathematics. The aim of this course is to supplement the pen-and-paper mathematics with a more palpable, more interactive variant of exploring mathematical concepts. Each chapter contains exercises and is a self-contained literate haskell file that requires no package dependencies other than those included in a basic Haskell installation. Selected goodies you can find in Haskell for Mathematicians: * Constructive topology via domain semantics of Haskell * Let the compiler verify theorems of intuitionistic logic * Two implementations of exact real numbers: signed-digit and Conway's surreal numbers * Categories (of course!) * Detailed discussion of mathematical properties of monads such as commutative and affine monads * Detailed derivation of a probability measure monad that is actually affine (unlike sampling-based ones) Please use the darcs issue tracker for reporting typos, strange wording or incaccuracies. Also please don't hesitate to point me to existing work that might be worth mentioning or incorporating in the monograph. Cheers Olaf

3 2

Utrecht Summer School on Advanced Functional Programming 2022
by Swierstra, W.S. (Wouter) 08 Apr '22

08 Apr '22

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

1 0

Typechecker complains about untouchable types
by rowan goemans 07 Apr '22

07 Apr '22

Hello everyone, I'm running into a type error I don't quite understand why it's happening. Consider this type class and function: ``` class KnownNat n => F (n :: Nat) foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int foo f = let _ = f (Proxy @n) in 0 ``` This typechecks with no issues. But once I add an LTE constraint to the type class it won't typecheck and complains about an untouchable type. ``` class (KnownNat n, 1 <= n) => F (n :: Nat) foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int foo f = let _ = f (Proxy @n) in 0 ``` with this error: ``` test.hs:11:8: error: • Could not deduce (F n0) from the context: F n bound by the type signature for: foo :: forall (n :: Nat). F n => (F n => Proxy n -> Proxy n) -> Int at test.hs:11:8-58 The type variable ‘n0’ is ambiguous • In the ambiguity check for ‘foo’ To defer the ambiguity check to use sites, enable AllowAmbiguousTypes In the type signature: foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int | 111 | foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ test.hs:11:8: error: • Couldn't match type ‘n0’ with ‘n’ ‘n0’ is untouchable inside the constraints: F n0 bound by a type expected by the context: F n0 => Proxy n0 -> Proxy n0 at test.hs:11:8-58 ‘n’ is a rigid type variable bound by the type signature for: foo :: forall (n :: Nat). F n => (F n => Proxy n -> Proxy n) -> Int at test.hs:11:8-58 Expected type: Proxy n0 -> Proxy n0 Actual type: Proxy n -> Proxy n • In the ambiguity check for ‘foo’ To defer the ambiguity check to use sites, enable AllowAmbiguousTypes In the type signature: foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int | 111 | foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int | ^^^^^^^^^^^^^^^^^^^^ ``` Interestingly adding an equality constraint on `n` does also work: ``` class (KnownNat n, 1 ~ n) => F (n :: Nat) foo :: forall n. F n => (F n => Proxy n -> Proxy n) -> Int foo f = let _ = f (Proxy @n) in 0 ``` Anyone have any clue what is going on here? Best regards, Rowan Goemans

3 2

[ANN] Jacinda 1.0.0.0 - a functional text processing language complementing sed, awk, etc.
by Vanessa McHale 07 Apr '22

07 Apr '22

Hi all, I have released the 1.0.0.0 version of Jacinda, an expression-oriented text processing language for the command-line. You can find it here (Linux, mainly): https://github.com/vmchale/jacinda/releases/tag/1.0.0.0 Cheers, Vanessa McHale

2 1

RFC: removing “alternative installation methods” from haskell.org (or finding them owners)
by Tom Ellis 04 Apr '22

04 Apr '22

The Haskell.org committee is considering removing the "alternative installation options" section from the [downloads page of haskell.org](https://www.haskell.org/downloads/) and we seek the opinion of the community. If you would like to share your opinion we prefer that you do so [on the haskell.org issue tracker](https://github.com/haskell-infra/www.haskell.org/issues/170), but failing that, in this email thread is fine too. ### Background The [downloads page of haskell.org](https://www.haskell.org/downloads/) suggests using ghcup and stack to obtain a toolchain. These two tools are widely used in the community, actively maintained and kept up-to-date. The page also provides a number of "alternative installation options" (see below, or on the page itself, for the list). The Haskell.org committee does not have the resources to ensure that these alternative installation options are kept maintained and confirmed working. We don't even know if anyone uses them. Anyone who uses them is likely to be an "advanced user" anyway, since they require more expertise to implement. stack and ghcup presumably work well on all those platforms, are the most well-maintained installation options and most suitable for beginners. ### Possibilities We have a couple of options: 1. Remove all the alternative installation options. 2. Keep (some of) the alternative installation options and find community volunteers to maintain them. The volunteers will be responsible for ensuring verifying on a regular basis that their instructions are still working, submitting timely corrections when necessary, and responding promptly on the issue tracker to questions about their installation instructions. ### What we would like from you * Please share your opinion about removing the alternative installation options, especially if you are a user of one of them! * If you are willing to maintain an alternative installation option, please speak up! ### Current alternative installation options * Linux Ubuntu (confusing (see https://github.com/haskell-infra/www.haskell.org/issues/16) and probably outdated) * Linux Debian (links to https://downloads.haskell.org/~debian/ which doesn't support Debian 11 Bullseye) * Linux Fedora * Linux EPEL for RHEL/CentOS/etc * Linux Arch * Linux openSUSE Leap * Linux openSUSE Tumbleweed * Linux Gentoo * Windows Chocolatey

11 32

Model beverage
by Daneel Yaitskov 04 Apr '22

04 Apr '22

Hi List, I came to Haskell from Java. At the beginning I was trying to map traditional notions of mainstream languages onto the FP world as “How to replace inheritance and late binding?”, etc. If Java developers drink coffee, then what is the model beverage for haskellers? “Psyllium Husk” fits the role, because besides phonetic similarities, the beverage is lazy (the recipe is simple - mix powder with water) and immutable (goes through the intestinal tract largely unaltered). Plus it is far off mainstream. -- Best regards, Daniil Iaitskov

2 1

Default http2 library to use for client side?
by Ruben Astudillo 04 Apr '22

04 Apr '22

Hello Cafe I have been looking at hackage on what is the status for http2 **client** libraries. I haven't be able to grasp what is the default or recommended solution on this space. So far I have gotten the following impressions: 1. The usual candidates such as req / wreq libraries don't seem to support it. This is caused by they being based on `http-client`. 2. There is an http2-client [1] library that fits the bill. It uses Kazu's http2 [2] underneath, but it is upper bounded to major version 2 of that library. Kazu's library is now at major version 3 and it cannot be made to use the updated version easily. 3. Kazu's http2 library on major version 3 has a module called Network.HTTP2.Client which is even more low-level than what the previous option provided but it seems recently developed. It has a code sample. 4. Haskellers are not that interested on client side http2. I am no expert on this protocol, but it seems that there is some compatibility on it where you can make an http1.1 call and the server will handle it transparently (don't quote me on this). But Haskellers certainly were (are?) excited for http2 server support on warp which landed around 2015-2016. I have concluded that using `http2` [2] with the client module as my best bet. Is this analysis correct? or should I be looking a other packages that I haven't considered? Thanks for you time reading this email. [1]: <https://hackage.haskell.org/package/http2-client> [2]: <https://hackage.haskell.org/package/http2> -- Rubén. (pgp: 1E88 3AC4 89EB FA22)

1 0

Re: [Haskell-cafe] Model beverage
by Olaf Klinke 03 Apr '22

03 Apr '22

>Well if that's the path we're going down, consider: > >Mushroom tea. > >It will take you outside of time, make you contemplate infinity, and take >your thoughts in abstract directions few other experiences can prepare >you >for; but in the end you come away surprisingly refreshed! > I'd rather reserve that one for dependently-typed languages. ;-) But it shows once more how biased we Europeans are towards alcoholic drugs. Olaf >On Sat, Apr 2, 2022, 9:00 AM Olaf Klinke <olf(a)aatal-apotheke.de> wrote: > >> Absinthe comes to mind. It is very potent, popular among >> philosophers but >> drives you crazy if consumed regularly, in large quantities.

1 0

Fully Funded PhD Positions in the Safety and Security of Advanced Systems Group (Exeter, UK, Deadline 2022-04-29)
by Achim D. Brucker 03 Apr '22

03 Apr '22

We have two fully funded PhD scholarships for UK applicants in the Security and Trust of Advanced Systems Group [1] (Prof. Achim Brucker [2] and Dr. Diego Marmsoler [3]) at the Department of Computer Science of the University of Exeter, UK [4]. We are looking for enthusiastic and outstanding Computer Science or Mathematics students with a strong background in at least one of the following topics: * safety or security of (software) systems, * formal modelling or formal reasoning/verification, * program analysis or program verification, * language-based security, * semantics of programming languages, * theorem proving, model checking, * cryptographic protocols, * distributed systems (e.g., blockchain), * software security, * cyber-physical systems, * specification-based testing, and * design and implementation of security architectures. The positions offer the flexibility to define the PhD topic jointly between the successful candidate and the supervisors. Interested candidates should contact the potential supervisor Prof. Achim Brucker (a.brucker(a)exeter.ac.uk) or Dr. Diego Marmsoler (d.marmsoler(a)exeter.ac.uk) to discuss their application. For more details, please consult the official advertisements: * Compositional Verification of Smart Contracts in Isabelle: https://www.exeter.ac.uk/study/funding/award/?id=4326 * Formal Verification for Safety- or Security-Critical Systems: https://www.exeter.ac.uk/study/funding/award/?id=4328 The closing date for applications is midnight on the 29th April 2022. Best, Achim and Diego [1] http://emps.exeter.ac.uk/computer-science/research/cyber-security/ [2] https://www.brucker.ch/ [3] https://marmsoler.com/ [4] http://emps.exeter.ac.uk/computer-science/ -- Prof. Achim Brucker | Chair in Cybersecurity & Head of Group | University of Exeter https://www.brucker.ch | https://logicalhacking.com/blog @adbrucker | @logicalhacking

1 0

Model beverage
by Olaf Klinke 03 Apr '22

03 Apr '22

> Hi List, > > I came to Haskell from Java. At the beginning I was trying to map > traditional notions of mainstream languages onto the FP world as “How to > replace inheritance and late binding?”, etc. > > If Java developers drink coffee, then what is the model beverage for > haskellers? > > “Psyllium Husk” fits the role, because besides phonetic similarities, the > beverage is lazy (the recipe is simple - mix powder with water) and > immutable (goes through the intestinal tract largely unaltered). Plus it is > far off mainstream. > > > -- > > Best regards, > Daniil Iaitskov Absinthe comes to mind. It is very potent, popular among philosophersbut drives you crazy if consumed regularly, in large quantities. Cheers, Olaf

2 1

Can't use TypeApplications with polymorphic let bind
by Georgi Lyubenov 29 Mar '22

29 Mar '22

Dear Cafe, I recently came upon this little "type-inference puzzle". Can anyone shine some light on why the third example doesn't compile? ``` {-# LANGUAGE TypeApplications #-} -- doesn't work -- I expect this, not sure why it happens {- class C m where c :: () -> m instance C Int where c () = 0 instance C Bool where c () = False f :: (Int, Bool) f = let x = c in (x (), x ()) -} -- works -- I expect this, not sure why it happens {- class C m where c :: () -> m instance C Int where c () = 0 instance C Bool where c () = False f :: (Int, Bool) f = let x u = c u in (x (), x ()) -} -- doesn't work -- I don't expect this, not sure why it happens {- class C m where c :: () -> m instance C Int where c () = 0 instance C Bool where c () = False f :: (Int, Bool) f = let x u = c u in (x @Int (), x @Bool ()) -- wtf.hs:54:5: error: -- • Cannot apply expression of type ‘() -> m0’ -- to a visible type argument ‘Int’ -- • In the expression: x @Int () -- In the expression: (x @Int (), x @Bool ()) -- In the expression: let x u = c u in (x @Int (), x @Bool ()) -- | -- 54 | (x @Int (), x @Bool ()) -- | ^^^^^^^^^ -} ``` Cheers, Georgi

4 3

New Executive Director for the Haskell Foundation
by Richard Eisenberg 29 Mar '22

29 Mar '22

Official announcement on Discourse: https://discourse.haskell.org/t/new-executive-director-for-the-haskell-foun… <https://discourse.haskell.org/t/new-executive-director-for-the-haskell-foun…> Text repeated here (but responses from David and Andrew are already on Discourse): It is my great pleasure to announce the next Executive Director of the Haskell Foundation: David Thrane Christiansen. David is a long-time Haskeller who comes with a demonstrated passion for functional programming, having done intensive work with Idris, Racket, and Haskell, among other formative experiences. In particular, David was a key part of the Idris community when it morphed from a smallish language project to one more widely used. David holds a PhD in Computer Science from the IT University of Copenhagen (the city where he currently lives), has co-authored a book on dependent types (The Little Typer), and has worked for Galois and Deon Digital. Lest anyone get worried about one PhD excited about dependent types (me) involved in hiring another PhD excited about dependent types (David): over the course of many conversations about the HF, David has impressed upon me the importance of reaching out beyond current Haskell communities, seeking new voices and approaches. Haskell is a language that anyone can master -- but we have work to do to have its perception match that reality. I know David is committed to that course of action, and of focusing on the practical aspects of Haskell use that affect the Haskell community broadly. David begins his employment with the HF on Monday, May 2. About the process: The HF formed a Transition Committee (our charter is public: https://gitlab.haskell.org/hf/meta/-/blob/main/committees/transition.md) comprising José Pedro Magalhães (chair), Ed Kmett, and myself. We put together a call for applications and processed these applications as they came in. Applicants that passed an initial screening interview were given four additional interviews. The Transition Committee then made a recommendation to the Board based on the written feedback from these interviews, and the Board voted unanimously and enthusiastically to accept the recommendation to hire David. I hope you join me in being excited about this next chapter for the Haskell Foundation! Richard

1 0

First CfP: FMBC 2022 - 4th International Workshop on Formal Methods for Blockchains
by Zaynah Dargaye 29 Mar '22

29 Mar '22

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

1 0

[ANN] base16-0.3.2.0, base32-0.2.2.0, base64-0.4.2.4
by Emily Pillmore 29 Mar '22

29 Mar '22

Hello All, I'm pleased to announce that `base16`, `base32`, and `base64` have been updated to support GHC 9.2.x. In the most recent versions, due to GHC issue #20338 in which `targetByteOrder` was incorrect on Big Endian architectures, the required GHC version lower bound has been upped to GHC 8.10.x. In this version, GHC 8.10.x was silently patched to fix this behavior. Cheers, Emily

1 0

inference with implicitparams seems broken
by rowan goemans 28 Mar '22

28 Mar '22

Hello everyone, I wonder why the following taken from an stackoverflow answer doesn't work: https://stackoverflow.com/questions/71184922/is-it-possible-to-infer-a-type…. Code of the answer posted here verbatim: ``` {-# LANGUAGE ImplicitParams #-} {-# LANGUAGE RankNTypes #-} module Temp where withX :: Int -> ((?x :: Int) => r) -> r withX x r = let ?x = x in r somethingThanNeedsX :: (?x :: Int) => Int somethingThanNeedsX = ?x + 2 foo :: Int foo = bar where bar = withX 42 baz baz = somethingThanNeedsX ``` This won't compile with the error message: ``` Orig.hs:19:11: error: • Unbound implicit parameter (?x::Int) arising from a use of ‘somethingThanNeedsX’ • In the expression: somethingThanNeedsX In an equation for ‘baz’: baz = somethingThanNeedsX In an equation for ‘foo’: foo = bar where bar = withX 42 baz baz = somethingThanNeedsX | 19 | baz = somethingThanNeedsX ``` If you give `baz` a type signature which includes the implicit param it compiles. But I think this is a bug. GHC should not require a type signature here. I tried searching for a GHC ticket but I couldn't find one. But that might also be down to me not using the right query. Anyway my question is, is this expected behavior? This really makes implicit params less ergonomic. Best regards, Rowan Goemans

3 7

Munich Haskell Meeting, 2022-03-30 @ 19:30
by Leah Neukirchen 27 Mar '22

27 Mar '22

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Wednesday, March 30 at **Augustiner-Gaststätte Rumpler** at 19h30 CEST. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-mar-2022/ Everybody is welcome! Local COVID rules apply. cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0

Hatlab: My attempt to make a library inspired by Matlab and NumPy
by TeraTux 27 Mar '22

27 Mar '22

Greetings! I made a library which implements functions similar to those in Matlab or NumPy. The code is not much clean yet, you can see it at https://gitlab.com/Hume2/hatlab . The functions with comments are intended to be used. I want to know if it is a good start or I just wasted time. The matrices can have arbitrary dimensions, starting from 0D matrices, which are basically scalars. Operations like + - * / are element-wise. I also implemented broadcasting of these operations. I also implemented indexing. Some examples: a = matrix2D [[1,2,3],[4,5,6],[7,8,9]] a !# [2,2] -- element at index [2,2] a !$ [At 1, All] -- 1st row a !$ [To (-1), All] -- all rows except the last one a !$ [Where $ a ># 5] -- all elements bigger than 5 (The ># operator returns a matrix of bools, I will come to that later.) It is also possible to update a matrix. These operations do not copy all the elements from the original matrix, they just make another matrix which points to the original matrix at places where it was not changed. Some examples: a = eye 5 b = matrix2D [[1,2,3],[4,5,6],[7,8,9]] a !:[FromTo 1 4, FromTo 1 4]:= b -- replace the middle square by a different matrix a !:[FromTo 1 4, FromTo 1 4]:= 1 -- set all values in the middle square to 1 a !:[FromTo 1 4, FromTo 1 4]:+= 1 -- add one to all values in the middle square a !:[FromTo 1 4, FromTo 1 4]:$= cos -- replace all values in the middle square by their cosine Operators are broadcasted the same way as in Matlab or NumPy. If one operand has size 1 and the other one has size N or vice-versa in given dimension, the operator acts as if the thinner matrix was repeated in the given dimension N times. Example: a = matrix1D [10, 20, 30] -- row vector b = matrix2D [[1], [2], [3]] -- column vector a + b -- returns [[11, 21, 31], [12, 22, 32], [13, 23, 33]] There is a function "scalar" which creates a 0D matrix out of any value, so we can do: a + (scalar 5) -- returns [15, 25, 35] a * (scalar 2) -- returns [20, 40, 60] If a type is in the class Num, Fractional or Floating, the matrix of the given type is also in the given class. Conversions are performed using the function "scalar", so we can write: a + 5 a * 2 because the "5" and "2" are then interpreted as 0D matrices. Operator * is interpreted as element-wise multiplication. To do matrix multiplication, use the × operator. It can be also used to multiply matrices with vectors. Examples: v = matrix1D [1,2,3] m = matrix2D [[1,0,1],[2,-1,1],[0,1,-1]] v × m -- multiply row vector v with matrix m m × v -- multiply matrix m with column vector v m × m -- multiply matrix m by itself There are also functions for element-wise boolean operations. They work similarly and they have the # suffix. Examples: a = matrix2D [[True, True], [False, False]] b = matrix2D [[True, False], [True, False]] a &# b -- element-wise and a |# b -- element-wise or There are also element-wise comparison functions in a similar fashion. Examples: a = eye 3 b = ones [3,3] a ==# b -- returns a matrix of bools saying where the element of matrix a is equal to the corresponding element in matrix b. a <# b -- similar as above except that it tests for being less than instead of equality. a ==# 1 -- Broadcasting works for these operators too, so this syntax is valid also. There are also other functions not described in this mail. I will not describe them here because this mail is already too long. Don't worry asking me if you don't understand the meaning of any function from my comments. I did not implement any algorithms for linear equation solving, not even any other matrix algorithms yet. If this library has any potential, I may do that in the future. Please, let me know if this library has any potential or it was just a waste of time. Hume2

1 0

Haskell Symposium 2022: Call for Papers
by Nadia Polikarpova 26 Mar '22

26 Mar '22

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

1 0

Accessing a MinGW/MSYS2 shell from Setup.hs
by Hécate 26 Mar '22

26 Mar '22

Hi everyone, I am writing a custom Setup.hs to do an Autotools build for a bundled library. This is easy everywhere with `process` _except_ Windows, because I can't get a shell with the Autotools in them, despite there definitely being one. `process` gives me a cmd.exe shell, which wouldn't know about the Autotools, and on Windows, _any_ GHC installation has to have certain POSIX stuff available, which is why it bundles MinGW. Is the shell I get from that accessible from Setup.hs, via `process` or otherwise? Cheers, Hécate -- Hécate ✨ 🐦: @TechnoEmpress IRC: Hecate WWW:https://glitchbra.in RUN: BSD

1 0

Call for Talks: Haskell Implementors' Workshop 2022
by Alejandro Serrano Mena 23 Mar '22

23 Mar '22

(apologies for multiple copies of this message) ACM SIGPLAN Haskell Implementors' Workshop https://icfp22.sigplan.org/home/hiw-2022 Ljubljana, Slovenia, 11 September 2022 Co-located with ICFP 2022 https://icfp22.sigplan.org/ Important dates --------------- Deadline: 11 July, 2022 (AoE) Notification: 11 August, 2022 Workshop: 11 September, 2022 The 14th Haskell Implementors' Workshop is to be held alongside ICFP 2022 this year in Ljubljana. It is a forum for people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure, to share their work and discuss future directions and collaborations with others. Talks and/or demos are proposed by submitting an abstract, and selected by a small program committee. There will be no published proceedings. The workshop will be informal and interactive, with open spaces in the timetable and room for ad-hoc discussion, demos, and lightning short talks. Scope and target audience ------------------------- It is important to distinguish the Haskell Implementors' Workshop from the Haskell Symposium which is also co-located with ICFP 2022. The Haskell Symposium is for the publication of Haskell-related research. In contrast, the Haskell Implementors' Workshop will have no proceedings -- although we will aim to make talk videos, slides and presented data available with the consent of the speakers. The Implementors' Workshop is an ideal place to describe a Haskell extension, describe works-in-progress, demo a new Haskell-related tool, or even propose future lines of Haskell development. Members of the wider Haskell community encouraged to attend the workshop -- we need your feedback to keep the Haskell ecosystem thriving. Students working with Haskell are specially encouraged to share their work. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimisation and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment Talks ----- We invite proposals from potential speakers for talks and demonstrations. We are aiming for 20-minute talks with 5 minutes for questions and changeovers. We want to hear from people writing compilers, tools, or libraries, people with cool ideas for directions in which we should take the platform, proposals for new features to be implemented, and half-baked crazy ideas. Please submit a talk title and abstract of no more than 300 words. Submissions can be made via HotCRP at https://icfphiw22.hotcrp.com until July 11th (anywhere on earth). We will also have lightning talks session. These have been very well received in recent years, and we aim to increase the time available to them. Lightning talks be ~7mins and are scheduled on the day of the workshop. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. Program Committee ----------------- * Pepe Iborra (Meta) * Gabrielle Keller (Utrecht University) * Emily Pilmore (Kadena) * Vladislav Zavialov (Serokell) * Alejandro Serrano (Tweag) Contact ------- * Alejandro Serrano <trupill at gmail.com>

1 0

Retro/indie Haskell to appreciate
by Rishiyur Nikhil 21 Mar '22

21 Mar '22

> I’m looking to appreciate “retro” Haskell projects, things from before stabilization/company use. > Such as: > ... > BlueSpec compiler https://github.com/B-Lang-org/bsc Note, the Bluespec compiler, though written in "retro" Haskell, remains in daily production use (as it has been, for 2 decades). Another project, written a few years ago but in totally "retro" style is Forvis, a complete executable spec for the RISC-V instruction set: https://github.com/rsnikhil/Forvis_RISCV-ISA-Spec Covers RV32 and RV64; unprivileged and privileged: unprivileged ISA: I (basic integer) M (integer multiply/divide) A (atomics) F, D (single and double precision floating point) C (compressed) privileged ISA: M (machine), S (supervisor) and U (user modes) Sv32, Sv39 and Sv48 virtual memory and has successfully booted a Linux kernel. Rgds, Nikhil

1 0

[announce] Stackage LTS 19 (ghc-9.0) & Nightly moved to ghc-9.2
by Jens Petersen 20 Mar '22

20 Mar '22

The Stackage Team is happy to announce the first release of the stable LTS 19 series of package sets over GHC 9.0.2: https://www.stackage.org/lts-19.0 We are also excited to announce that Nightly has been updated to use ghc-9.2.2 (thanks to heroic work by Adam Bergmark)! You can find a few more details in the short accompanying post: https://www.stackage.org/blog/2022/03/announce-lts-19-nightly-ghc9.2 Thank you to everyone in the Haskell community who contributed to make these new releases possible!

1 0

Haskell internships with Standard Chartered Bank in the UK
by José Pedro Magalhães 20 Mar '22

20 Mar '22

All details at https://discourse.haskell.org/t/haskell-internships-with-standard-chartered… Cheers, Pedro

1 0

Re: [Haskell-cafe] Retro/indie Haskell to appreciate
by Johannes Waldmann 19 Mar '22

19 Mar '22

> I’m looking to appreciate “retro” Haskell projects, If "retro" = "old", then look at this from 1997 https://github.com/jwaldmann/rx (state at first commit) And, I second what others have suggested: Paul Hudak: Haskore, https://web.archive.org/web/19970206084830/http://haskell.cs.yale.edu:80/ha… Peter Thiemann: Wash, http://www2.informatik.uni-freiburg.de/~thiemann/haskell/WASH/ The pinnacle of Haskell retrocomputing certainly is https://downloads.haskell.org/~ghc/0.29/ > ... things from before stabilization/company use. Haskell(98,2010) does have stability: language and core libraries adhere to the report. It's the companies that are destroying it :-) But you're right, they also spend effort on stabilization. When I cabalized my project in/around 2014, I was pleasantly surprised how little change it needed. Basically, just build-depend: haskell98. Don't read the actual source too closely - it's full of Lists and Ints, because, well .. little did I know at the time. On the other hand: naive means of expression, combined with absence, or ignorance, of libraries - makes future-proof software. Will you tell us the results of your appreciations? Are you "just" collecting sources? (already that is worthwhile) Compiling them? Running? Benchmarking? Writing a paper? I'd love to read that. - J.W.

2 2

Functional Conf 2022 - March 24-26 online - registrations closing soon
by John Sinclair 17 Mar '22

17 Mar '22

Hey Haskellers, It is just a week until Functional Conf 2022 kicks off online. We hope you will be among the 400+ attendees we expect at the conference. Learn more and register: https://confng.in/cHeBoXDf We have an exciting lineup of speakers for you this year including a keynote from Bartosz Milewski a guru of Haskell and Category Theory. You can check the full schedule here: https://confng.in/WCrltlIO This year, we are pleased to present Haskell talks by: - Bartosz Milewski (Author of "Category Theory for Programmers") - Tony Morris (Software Engineer @ Simple Machines) - Michael Snoyman (VP, Engineering @ FP Complete) - Curtis D'Alves (Ph.D Candidate @ McMaster University) - Evie Ciobanu (Senior Haskell Engineer @ Hasura) - Christopher Anand (Associate Professor @ McMaster University) - Siddharth Bhat (Student @ IIIT Hyderabad) - Saurabh Nanda (Founder @ Vacation Labs) - Quy Dai Nhan Thai (Software Engineer @ Google) - Auke Booij (Haskell Engineer @ Hasura) The conference is broader than just Haskell talks and offers an excellent opportunity to expand your understanding of what is happening in the world of functional programming. There will be opportunities for networking and socialising with other attendees in video hangouts, who knows who you might meet? The talks will be streamed via Zoom on the confengine.com platform. You can check out the talks from the last (in-person) Functional Conf on YouTube: https://confng.in/niusPTYB With exceptional speakers, enthusiastic learners and a supportive community of functional programmers you don't want to miss this! Register now to save your place: https://confng.in/_3SLI-9u

1 0

[ANNOUNCE] GHC 9.2.2 is not available
by Ben Gamari 16 Mar '22

16 Mar '22

The GHC developers are very happy to at announce the availability of GHC 9.2.2. Binary distributions, source distributions, and documentation are available at downloads.haskell.org: https://downloads.haskell.org/ghc/9.2.2 This release includes many bug-fixes and other improvements to 9.2.1 including: * A number of bug-fixes in the new AArch64 native code generator * Fixes ensuring that the `indexWord8ArrayAs*#` family of primops is handled correctly on platforms lacking support for unaligned memory accesses (#21015, #20987). * Improvements to the compatibility story in GHC's migration to the XDG Base Directory Specification (#20684, #20669, #20660) * Restored compatibility with Windows 7 * A new `-fcompact-unwind` flag, improving compatibility with C++ libraries on Apple Darwin (#11829) * Introduction of a new flag, `-fcheck-prim-bounds`, enabling runtime bounds checking of array primops (#20769) * Unboxing of unlifted types (#20663) * Numerous improvements in compiler performance. * Many, many others. See the [release notes] for a full list. As some of the fixed issues do affect correctness users are encouraged to upgrade promptly. Finally, thank you to Microsoft Research, GitHub, IOHK, the Zw3rk stake pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Moreover, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do open a [ticket][] if you see anything amiss. Happy compiling, - Ben [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new [release notes]: https://downloads.haskell.org/ghc/9.2.2/docs/html/users_guide/9.2.2-notes.h…

3 3

JOB | Developers (Edinburgh)
by James Tobin 15 Mar '22

15 Mar '22

Hello, I'm working with a global fintech company looking to hire for their new office in Edinburgh. Should there be frontend or backend people that work with the likes of Core Java, Javascript, Typescript, React, RxJS interested in forming a small development squad do get in touch. I can be reached using "JamesBTobin (at) Gmail (dot) Com". Kind regards, James

1 0

bracket and type family
by PICCA Frederic-Emmanuel 14 Mar '22

14 Mar '22

Hello I try to have a generic way to open and close ressources for my software class DataResource a where data OpenedDataResource a :: * acquireDataResource :: a -> IO (OpenedDataResource a) releaseDataResource :: OpenedDataResource a -> IO () the idea is to have a generic method like this withDataResource :: DataResource a => a -> (OpenedDataResource a -> IO r) -> IO r withDataResource r = bracket (acquireDataResource r) releaseDataResource and later another one for the bracket of Pipes. So I try with something simple -- File newtype H5FilePath = H5FilePath FilePath instance DataResource H5FilePath where data OpenedDataResource H5FilePath = File acquireDataResource (H5FilePath f) = openFile (pack f) [ReadOnly] Nothing releaseDataResource = closeFile but I end up with this sort of error src/Hkl/H5.hs:231:40: error: • Couldn't match type ‘File’ with ‘OpenedDataResource H5FilePath’ Expected type: IO (OpenedDataResource H5FilePath) Actual type: IO File • In the expression: openFile (pack f) [ReadOnly] Nothing In an equation for ‘acquireDataResource’: acquireDataResource (H5FilePath f) = openFile (pack f) [ReadOnly] Nothing In the instance declaration for ‘DataResource H5FilePath’ | 231 | acquireDataResource (H5FilePath f) = openFile (pack f) [ReadOnly] Nothing | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Hkl/H5.hs:232:25: error: • Couldn't match type ‘OpenedDataResource H5FilePath’ with ‘File’ Expected type: OpenedDataResource H5FilePath -> IO () Actual type: File -> IO () • In the expression: closeFile In an equation for ‘releaseDataResource’: releaseDataResource = closeFile In the instance declaration for ‘DataResource H5FilePath’ | 232 | releaseDataResource = closeFile | ^^^^^^^^^ cabal: Failed to build hkl-0.1.0.0 (which is required by exe:binoculars-ng from hkl-0.1.0.0). I do not understand why ? and more seriously, I do not know how to fix this. thanks for your help Frederic

2 1

Why is this package being compiled
by Henry Laxen 14 Mar '22

14 Mar '22

Dear Haskell friends, Is there a way to discover why a certain package is being compiled? In my case, the package cryptonite is a dependency of some other package, but I don't know which one. cryptonite doesn't compile on GHC 9.2.2, so if I can find out which package is causing it to be selected, perhaps I can work around my code so it (my code) does not depend on that package. I hope I am making myself clear. Any pointers would be appreciated. Best wishes, Nadine and Henry Laxen The rest is silence

4 4

Re: [Haskell-cafe] Retro/indie Haskell to appreciate
by Anthony Clayden 13 Mar '22

13 Mar '22

Hi Vanessa, in the same mould as 'Here documents' there's Hugs Extensible records /TRex https://www.haskell.org/hugs/pages/hugsman/exts.html#sect7.2 Not sure whether it counts as "retro": it still works, and is still superior to H2010 Datatype records (with GHC's extensions). AntC > I’m looking to appreciate “retro” Haskell projects, things from before stabilization/company use. > > Such as: > > > Hugs string extensions https://www.haskell.org/hugs/pages/users_guide/here-documents.html <https://www.haskell.org/hugs/pages/users_guide/here-documents.html>

1 0

[Call for participation] TFPiE and TFP online events March 16-18
by Peter Achten 13 Mar '22

13 Mar '22

------------------------------------------------------------------------------- C A L L F O R P A R T I C I P A T I O N 11th International Workshop on Trends in Functional Programming in Education + 23rd Symposium on Trends in Functional Programming 16 - 18 March 2022 wiki.tfpie.science.ru.nl/TFPIE2022 trendsfp.github.io ------------------------------------------------------------------------------- The programmes for TFPIE and TFP are online (all times are UTC+0): - TFPIE: https://wiki.tfpie.science.ru.nl/TFPIE2022 - TFP: https://trendsfp.github.io/schedule.html Registration is free. Prior to the events you receive a mail with the links to the Zoom meetings. The Symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. We aspire to be a lively environment for presenting the latest research results, and other contributions. The Trends in Functional Programming in Education workshops are an informal meeting intended for researchers, professors, teachers, and all professionals that use or are interested in the use of functional programming in education. TFPIE aims to be a venue where novel ideas, classroom-tested ideas, and work in progress on the use of functional programming in education are discussed. We foster a spirit of open discussion by having a review process for publication after the workshop. The program has a lot of interesting talks, possibilities for interaction, and keynote presentations: Trends in Functional Programming in Education keynote speaker: --------------------------------------------------------------- Peter Achten: The Perfect Functional Programming Course Trends in Functional Programming keynote speaker: ------------------------------------------------- Christiaan Baaij: Building a Haskell-to-Hardware compiler: Theory & Practice

1 0

TFPIE 2022 March 16 online - last call for participation
by Elena Machkasova 12 Mar '22

12 Mar '22

Dear All, TFPIE 2022 invites you to attend the conference on March 16 online. The program and the registration link are posted here: https://wiki.tfpie.science.ru.nl/TFPIE2022 Registration is free, but required for the zoom link to be sent. TFPIE is followed by TFP on March 17-18: https://trendsfp.github.io/index.html The registration is the same for the two conferences. More details: The 2022 edition of Trends in Functional Programming in Education will be held *virtually on March 16th 2022*, together with TFP which will be held on March 17-18. Note that *Lambda Days* <https://www.lambdadays.org/lambdadays2022> in Krakow, Poland has been rescheduled to July 28-29, and authors of TFPIE accepted papers are welcome to present their papers at the Lambda Days, in addition to the virtual presentations in March. The goal of TFPIE is to gather researchers, teachers and professionals that use, or are interested in the use of, functional programming in education. TFPIE aims to be a venue where novel ideas, classroom-tested ideas and work-in-progress on the use of functional programming in education are discussed. The one-day workshop will foster a spirit of open discussion by having a review process for publication after the workshop. Hope to see you there! Elena Machkasova -- Dr. Elena Machkasova Associate Professor of Computer Science Division of Science and Mathematics University of Minnesota, Morris Office: Sci 2325 (320) 589-6308 http://cda.morris.umn.edu/~elenam/ Pronouns: she/her/hers or any other

1 0

child thread control design patterns (was: GHC.Conc.threadStatus - documentation of ThreadDied :: ThreadStatus)
by Olaf Klinke 11 Mar '22

11 Mar '22

> Another good option for eternally long running things is to use race. I actually think race and concurrently are the much better go-to functions from the async library. I will often write code like: > > race_ daemonThread mainThread >>= \case > Left _ -> fail "Daemon terminated" > Right a -> return a > > This forks a thread for a daemon, a thread for the main thread, and then waits for either of them to finish. Assuming the daemon should never terminate, if it terminates the main thread will be terminated and the calling thread (e.g., main) will crash. If the other thread terminates early, that's fine, and we assume that's just the program gracefully terminating. In this case, the daemon will be cancelled. > > Ollie That is indeed a neat pattern. What are its advantages/disadvantages? The main thread in my case is the (Yesod) webserver. Perhaps Yesod does exactly what you propose, internally. Currently I use a bracket to kill all child threads when the webserver shuts down, like: main = bracket forkWorkers (traverse_ cancel) (const (warp port site)) Your idiom would be something like this? main = foldr race_ (warp port site) workers I also do want to include the possibility of a child (daemon) thread to crash without crashing the webserver (hence my original question), which your race solution does not cater for. In fact I will have a mix of perpetually running actions and actions that are fired on command of the user and then exit gracefully. Therefore I must save the original IO action somewhere, to be re- executed. And since operations on the child thread are initiated by the Yesod event handler, I can not pass them to the continuation of withAsync. Olaf

3 3

GHC.Conc.threadStatus - documentation of ThreadDied :: ThreadStatus
by Olaf Klinke 09 Mar '22

09 Mar '22

Dear Cafe, I had expected to see ThreadDied in the small example below. But when I compile with ghc --make -threaded -with-rtsopts=-N2 The output is: threadStatus: user error (child thread is crashing!) The status of my child is: ThreadFinished The output is not really a lie. But how do I determine whether a child thread has exited normally or not? Wouldn't you say a call to fail (or any other throwIO) should count as ThreadDied? The documentation of GHC.Conc.forkIO says: "... passes all other exceptions to the uncaught exception handler." and the documentation for GHC.Conc.ThreadStatus says: ThreadDied -- the thread received an uncaught exception One can provoke ThreadDied by using throwTo from the parent thread. So the emphasis in the documentation of ThreadDied should be on the word "received". This is a case of misleading documentation, in my humble opinion. The constructor should not be named ThreadDied because that suggests inclusion of internal reasons. Olaf -- begin threadStatus.hs import Control.Concurrent import GHC.Conc main = mainThread childThread :: IO () childThread = fail "child thread is crashing!" mainThread :: IO () mainThread = do child <- forkIO childThread threadDelay 5000 status <- threadStatus child putStr "The status of my child is: " print status -- end threadStatus.hs

5 6

Re: [Haskell-cafe] [ANNOUNCE] GHC 9.2.2 is not available
by Kazu Yamamoto 07 Mar '22

07 Mar '22

Hi George, FYI: https://twitter.com/kazu_yamamoto/status/1500643489985761282 --Kazu > Thanks Ben > > When I do an install on macos Monterey 12.2.1 (Intel) I get > > ghc-pkg-9.2.2 cannot be opened because the developer cannot be verified > > > On Sun, Mar 6, 2022 at 7:02 PM Ben Gamari <ben(a)well-typed.com> wrote: > >> >> The GHC developers are very happy to at announce the availability of GHC >> >> 9.2.2. Binary distributions, source distributions, and documentation are >> >> available at downloads.haskell.org: >> >> https://downloads.haskell.org/ghc/9.2.2 >> >> This release includes many bug-fixes and other improvements to 9.2.1 >> including: >> >> * A number of bug-fixes in the new AArch64 native code generator >> >> * Fixes ensuring that the `indexWord8ArrayAs*#` family of primops is >> handled >> correctly on platforms lacking support for unaligned memory accesses >> (#21015, #20987). >> >> * Improvements to the compatibility story in GHC's migration to the >> XDG Base Directory Specification (#20684, #20669, #20660) >> >> * Restored compatibility with Windows 7 >> >> * A new `-fcompact-unwind` flag, improving compatibility with C++ >> libraries on >> Apple Darwin (#11829) >> >> * Introduction of a new flag, `-fcheck-prim-bounds`, enabling runtime >> bounds >> checking of array primops (#20769) >> >> * Unboxing of unlifted types (#20663) >> >> * Numerous improvements in compiler performance. >> >> * Many, many others. See the [release notes] for a full list. >> >> As some of the fixed issues do affect correctness users are encouraged to >> >> upgrade promptly. >> >> Finally, thank you to Microsoft Research, GitHub, IOHK, the Zw3rk stake >> pool, Tweag I/O, Serokell, Equinix, SimSpace, and other anonymous >> contributors whose on-going financial and in-kind support has >> facilitated GHC maintenance and release management over the years. >> Moreover, this release would not have been possible without the hundreds >> >> of open-source contributors whose work comprise this release. >> >> As always, do open a [ticket][] if you see anything amiss. >> >> Happy compiling, >> >> - Ben >> >> >> [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new >> [release notes]: >> https://downloads.haskell.org/ghc/9.2.2/docs/html/users_guide/9.2.2-notes.h… >> >> _______________________________________________ >> Glasgow-haskell-users mailing list >> Glasgow-haskell-users(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users >>

1 0

ANN: stack-2.7.5
by Emanuel Borsboom 06 Mar '22

06 Mar '22

See https://haskellstack.org/ for installation and upgrade instructions. **Changes since v2.7.3:** Behavior changes: * Cloning git repositories isn't per sub-directory anymore, see [#5411](https://github.com/commercialhaskell/stack/issues/5411) Other enhancements: * `stack setup` supports installing GHC for macOS aarch64 (M1) * `stack upload` supports authentication with a Hackage API key (via `HACKAGE_KEY` environment variable). Bug fixes: * Ensure that `extra-path` works for case-insensitive `PATH`s on Windows. See [rio#237](https://github.com/commercialhaskell/rio/pull/237) * Fix handling of overwritten `ghc` and `ghc-pkg` locations. [#5597](https://github.com/commercialhaskell/stack/pull/5597) * Fix failure to find package when a dependency is shared between projects. [#5680](https://github.com/commercialhaskell/stack/issues/5680) * `stack ghci` now uses package flags in `stack.yaml` [#5434](https://github.com/commercialhaskell/stack/issues/5434) **Thanks to all our contributors for this release:** * Emanuel Borsboom * HaskellMouse * Julian Ospald * kocielnik * Matt Audesse * Michael Snoyman * MikaelUrankar * Muhammed Zakir * Natan Lao * Patryk Kocielnik * tkaaad97

1 0

22nd Midlands Graduate School, 10-14 April 2022: Call for Participation
by Andrei Popescu 06 Mar '22

06 Mar '22

CALL FOR PARTICIPATION 22nd Midlands Graduate School (MGS'22) in the Foundations of Computing Science 10-14 April 2022, Nottingham (UK) https://www.cs.nott.ac.uk/~psznk/events/mgs22.html OVERVIEW MGS is an annual spring school that offers an intensive programme of lectures on the mathematical foundations of computing. While the school addresses especially PhD students in their first or second year, it is also open to UG and MSc students, postdocs, participants from the industry, and generally everyone interested in its topics. MGS'22 is the school's 22nd incarnation. PROGRAMME MGS'22 offers eight courses: - our invited course by Andrej Bauer - three basic courses on category theory, proof theory, and HoTT/UF with agda, which require no previous experience - four advanced courses on topos theory, string diagrams, coalgebra, and graph transformations. REGISTRATION Participation at MGS'22 costs GBP 320. Please see the website https://www.cs.nott.ac.uk/~psznk/events/mgs22.html for details, point "Registration". The fee covers participation in all lectures and exercise classes, refreshments in coffee breaks, and a conference dinner. Please note that you have to book accommodation yourselves but there are rooms available on campus. Places are limited and will be allocated on a first-come-first-served basis. If you would like to participate, please register early to secure a place. The registration period closes as soon as all places are filled or on March 20, whichever is sooner. ORGANISATION Please direct all queries about MGS'22 to Thorsten Altenkirch and Nicolai Kraus, thorsten....(a)nottingham.ac.uk nicolai....(a)nottingham.ac.uk

1 0

data type familly and makeLenses
by PICCA Frederic-Emmanuel 04 Mar '22

04 Mar '22

Hello, I defined a typeclass like this with a data familly class HasConfig a where data BinocularsConfig a :: * new :: (MonadIO m, MonadLogger m, MonadThrow m) => Maybe FilePath -> m (BinocularsConfig a) getConfig :: Maybe FilePath -> IO (Either String (BinocularsConfig a)) combineWithCmdLineArgs :: BinocularsConfig a -> Maybe ConfigRange -> Maybe (Path Abs Dir) -> BinocularsConfig a update :: (MonadIO m, MonadLogger m, MonadThrow m) => FilePath -> m (BinocularsConfig a) the instance is for now instance HasConfig PreConfig where data BinocularsConfig PreConfig = BinocularsPreConfig { _binocularsPreConfigProjectionType :: ProjectionType } deriving (Eq, Show) [...] Since I use Ini to serialize/un-serialize the configuration, I need lens for this type My question is how can I generate the like easily makeLenses ''(BinocularsConfig PreConfig) does not work thanks for considering Frederic

3 3

order of assertEqual arguments is counterintuitive
by Daneel Yaitskov 02 Mar '22

02 Mar '22

Hi List, I noticed, that I pay more attention than I should, when working with assertions, because I am not sure about argument order i.e. whether the expected value goes first or vice-versa. Does anybody have similar thought? Such subtle detail should be easy to grasp with regular practice, but I observe difficulties and I suspect that there is a logical reason for that. Unit tests appeared long time ago in Java and spread over all languages. HUnit library inherited de facto standard assert function name and signature. I don't know reasoning behind original signature. I spell "assertEqual" expression as: "Assert that x equals to y" "y" sounds like a model value (i.e. expected value). In assignments "x <- y" y is the model value, because it defines "x". You get "x" - value on the left not on the right. Similar issue with test fixing - I always have to check first, that an expected value is actually one. There is no type safety preventing mixing arguments. I had to open and comprehend a source file with test, because test log is not 100% safe. -- Best regards, Daniil Iaitskov

8 7

generic way to construct and deconstruct a newtype
by PICCA Frederic-Emmanuel 01 Mar '22

01 Mar '22

Hello, I try to write some code use to parse an ini file for one of my softwares, using config-ini[1]. In this config file I have scientific values with units, meter, angstrom, degrees, etc... So I created a bunch of newtype in order to deal with this part of the config file newtype Meter = Meter (Length Double) deriving (Eq, Show) newType Angstrom = Angstrom (Length Double) [...] Then I created a typeclasse in order to have a generic way to extract the fileds values using the BiDir api [2] class HasFieldValue a where fieldvalue :: FieldValue a instance HasFieldValue Meter where fieldvalue = FieldValue { fvParse = mapRight (Meter . (*~ meter)) . fvParse auto , fvEmit = \(Meter m) -> pack . show . (/~ meter) $ m } instance HasFieldValue Angstrom where fieldvalue = FieldValue { fvParse = mapRight (Meter . (*~ angstrom)) . fvParse auto , fvEmit = \(Angstrom m) -> pack . show . (/~ angstrom) $ m } I would like to factorize via a method which should take at least an unit, in order to avoid repetition. I started with this sort of funtion, but I do not know how to write something generic for <???> numberUnit :: (Num a, Fractional a, Read a, Show a, Typeable a) => Unit m d a -> FieldValue (Quantity d a) numberUnit u = FieldValue { fvParse = mapRight (<???> . (*~ u)) . fvParse number' , fvEmit = \(<???> v) -> pack . show . (/~ u) $ v } thanks for your help [1] https://hackage.haskell.org/package/config-ini-0.2.4.0 [2] https://hackage.haskell.org/package/config-ini-0.2.4.0/docs/Data-Ini-Config…

2 3

Initiating package takeover: size-based and testing-feat
by Brent Yorgey 28 Feb '22

28 Feb '22

Hi everyone, Wen Kokke (cc'd) and I intend to take over maintainership of the size-based and testing-feat packages. I have tried to contact the current maintainer, Jonas Duregård (also cc'd), multiple times over the past year via both GitHub and email. I have both requested new releases incorporating existing PRs, and also offered to help with maintenance, but I have not received any response. I don't intend to do do anything fancy with the packages or make major changes, but they are nice packages and I would like to see them able to build on newer GHCs. Happy to hear any comments or feedback (especially from Jonas), but in any case, this email serves as official notice of our intention. If I still haven't heard from Jonas after a while I will proceed with contacting the Hackage admins to request a transfer of maintainership. -Brent

1 0

2nd Call for Participation: Virtual BOB 2022 (March 11)
by Stefan Wehr 23 Feb '22

23 Feb '22

========================================================================= BOB 2022 Conference “What happens if we simply use what’s best?” March 11, 2022, online 0100+UTC https://bobkonf.de/2022/ Program: https://bobkonf.de/2022/program.html Registration: https://bobkonf.de/2022/program.html ========================================================================= BOB conference is a place for developers, architects, and decision-makers to explore technologies beyond the mainstream in software development and to find the best tools available to software developers today. Our goal is for all participants of BOB to return home with new insights that enable them to improve their own software development experience. The program features 14 talks and 8 tutorials on current topics: https://bobkonf.de/2022/program.html The subject range includes functional programming, effects, distributed programming, formal methods, generative art, event-driven systems, the human brain, Haskell, Python, Scala, Lua, Clojure, Erlang, Nix, and others. Derek Dreyer will give the keynote talk. Due to COVID-related risks, BOB will take place online, entirely within a Gather Town virtual world. We've placed special emphasis on enabling social, casual interaction, in addition to our stellar program. Registration is open - student tickets are €10, regular tickets are €30. As always, grants are available for members of groups underrepresented in tech: https://bobkonf.de/2022/program.html

1 0

Explicit type signatures and wrappers / impedance-matching
by Benjamin Redelings 22 Feb '22

22 Feb '22

Hi, I am trying to understand (and implement) how Haskell handles explicit type signatures. Specifically, I'm trying to understand how explicit type signatures interact with wrappers. 1. Is there any paper or documentation that explains wrappers and/or explicit type signatures in detail? There are some non-obvious details regarding wrappers, such as using eliminating type arguments by supplying the Any type as an argument... 2. Do explicit type signatures impose any unification constraints, or can they be thought of entirely in terms of wrappers? For example, if we have g :: Int -> Int (f,g) = (\x ->x, f) then the signature for g is added to the environment when typing the right-hand-side. One way that this could be handled is: (i) typecheck rhs -> rhs_type (ii) generate type of lhs with fresh variables for every binder -> lhs_type = (a,b) (iii) unify(lhs_type, rhs_type) (iv) do one-way unification: match(inferred-type-of-g, explicit-type-for-g) Is this correct? Step (iv), the way that I have written it, would impose unification constraints. Without considering the type signature, we would have { f_mono :: a -> a, g_mono :: a -> a} If we just use wrappers to impose the explict type, it seems like we would get something like let tup = /\a.let {(f:a,g:a) = (\x:a -> x:a, f::a->a) f = /\a.case tup a of (f,g) -> f g = case tup @Int of (f,g) -> g where f :: forall a.a ->a and g :: Int -> Int. THIH seems to imply that type signatures are merely checked: no unification constraints are imposed (I think). However, ghc reports f :: Int -> Int. I apologize if this is a dumb question. I have found the definition of HsWrapper in ghc/compiler/GHC/Tc/Types/Evidence.hs, but I am still struggling a bit. thanks! -BenRI

2 4

[TFP'22] final call for papers: Trends in Functional Programming 2022 (deadline March 7 2022)
by Peter Achten 21 Feb '22

21 Feb '22

================ TFP 2022 ================= == Final Call For Papers == == registration opened == =========================================== 23rd Symposium on Trends in Functional Programming 17-18 March, 2022 Online event https://trendsfp.github.io/index.html Due the pandemic, we have had to make TFP virtual this year. As a result, we've decided to push back the deadlines and conference date by a few weeks. In particular, the pre-symposium deadline for submitting the first version of your paper is now just after the ICFP deadline. == Important Dates == Submission deadline for draft papers Monday 7th March, 2022 Notification for draft submissions Friday 11th March, 2022 Symposium dates Thursday 17th - Friday 18th March, 2022 Submission deadline for post-symposium reviewing Wednesday 6th April, 2022 Notification for post-symposium submissions Friday 27th May, 2022 The Symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions. == Scope == The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: * Research Articles: Leading-edge, previously unpublished research work * Position Articles: On what new trends should or should not be * Project Articles: Descriptions of recently started new projects * Evaluation Articles: What lessons can be drawn from a finished project * Overview Articles: Summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: * Functional programming and multicore/manycore computing * Functional programming in the cloud * High performance functional computing * Extra-functional (behavioural) properties of functional programs * Dependently typed functional programming * Validation and verification of functional programs * Debugging and profiling for functional languages * Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. * Interoperability with imperative programming languages * Novel memory management techniques * Program analysis and transformation techniques * Empirical performance studies * Abstract/virtual machines and compilers for functional languages * (Embedded) domain specific languages * New implementation strategies * Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2022 program chairs, Wouter Swierstra and Nicolas Wu. == Best Paper Awards == To reward excellent contributions, TFP awards a prize for the best paper accepted for the formal proceedings. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. A prize for the best student paper is awarded each year. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, that paper will then receive both prizes. == Instructions to Author == Papers must be submitted at: https://easychair.org/conferences/?conf=tfp22 Authors of papers have the choice of having their contributions formally reviewed either before or after the Symposium. == Post-symposium formal review process == Draft papers will receive minimal reviews and notification of acceptance for presentation at the symposium. Authors of draft papers will be invited to submit revised papers based on the feedback received at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. == Paper categories == Draft papers and papers submitted for formal review are submitted as extended abstracts (4 to 10 pages in length) or full papers (20 pages). The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate which authors are research students, and whether the main author(s) are students. A draft paper for which all authors are students will receive additional feedback by one of the PC members shortly after the symposium has taken place. == Format == Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS web site. == Program Committee == Guillaume Allais University of St Andrews José Manuel Calderón Trilla Galois, Inc. Stephen Chang University of Massachusetts Boston Matthew Flatt University of Utah Jeremy Gibbons University of Oxford Zhenjiang Hu Peking University Mauro Jaskelioff CIFASIS / Universidad Nacional de Rosario Moa Johansson Chalmers University of Technology Shin-ya Katsumata National Institute of Informatics Oleg Kiselyov Tohoku University Bas Lijnse Netherlands Defence Academy / Radboud University Nijmegen Kazutaka Matsuda Tohoku University Nico Naus Virginia Tech Christine Rizkallah University of New South Wales Alejandro Serrano 47 Degrees Amir Shaikhha Ecole Polytechnique Fédérale de Lausanne Aaron Stump University of Iowa Wouter Swierstra (Co-chair) Utrecht University Baltasar Trancón Y Widemann Semantics GmbH Nicolas Wu (Co-chair) Imperial College London Ningning Xie University of Hong Kong

1 0

Re: [Haskell-cafe] recommend book for self-study group
by Johannes Waldmann 20 Feb '22

20 Feb '22

> https://www.seas.upenn.edu/~cis194/spring13/lectures.html I agree strongly. See also https://haskell.markmail.org/search/?q=CIS194 Then, you want to quickly move to https://thinkingwithtypes.com/ (the second half of CIS194 already shows the way) ... because that's what makes present-day Haskell useful and unique (and not "thinking with lists (and Ints)", as some (LISP-era) introductory texts want you to believe) > ... I just don't have time to prepare and deliver a class. then hire a (remote) consultant? Buy a few copies of Maguire's book. - J.W.

2 1

recommend book for self-study group
by Amy de Buitléir 20 Feb '22

20 Feb '22

I want to encourage more people at my company to learn Haskell, but I just don't have time to prepare and deliver a class. But then it occurred to me I could lead a self-study group, where people learn on their own but would have a forum to discuss what they're learning and ask questions. I would encourage people to answer each other's questions, but I would answer the more difficult questions. What book(s) do you think would be best suited for self-study? The participants would all be experienced programmers, but would likely have no knowledge of functional programming?

6 5

Munich Virtual Haskell Meeting, 2022-02-22 @ 19:30
by Leah Neukirchen 18 Feb '22

18 Feb '22

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Tuesday, February 22 on Jitsi at 19:30 CEST. **Due to the pandemic, this meeting will take place online!** For details see here: https://muenchen.haskell.bayern/dates.html A Jitsi link to join the room is provided on the page. Everybody is welcome, especially the Haskellers from Bavaria that do not usually come to our Munich meetings due to travel distance! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0