- Haskell-Cafe - Haskell.org

Logging
by Hilco Wijbenga 08 Dec '21

08 Dec '21

Hi all, I just started using "logging" (https://hackage.haskell.org/package/logging) which is based on "fast-logger" (https://hackage.haskell.org/package/fast-logger) It all works fine except that the timestamp in the log message is output as UTC. I would like it to use my local (i.e. system) TZ. I tried setting the TZ environment variable explicitly (before invoking my main) and by setting it in code (System.Environment.setEnv) but it doesn't make any difference. I did not find anything in either API about this so I'm out of ideas. If this is simply impossible, does anyone have a recommendation for another logging package? Cheers, Hilco

11 18

Re Is the Haskell list comprehension just a Cartesian product machine?
by Douglas McIlroy 08 Dec '21

08 Dec '21

> could I explain Haskell list comprehensions as basically just a > Cartesian/cross product machine? Another deviation from the simple explanation: the pair (2,1) never appears in an enumeration from the Haskell expression [(x,y) | x<-[1..], y<-[1..]] Although the notation is adapted from set theory, it does not necessarily reflect the meaning of its set-theory analog. A list comprehension specifies an enumeration order. In the present case that ordering is not well founded: some elements have an infinite descending chain of predecessors and thus never appear in the enumeration. Doug

1 0

Is the Haskell list comprehension just a Cartesian product machine?
by Galaxy Being 08 Dec '21

08 Dec '21

If I were a teacher of high-schoolers wanting to add some theory to Haskell could I explain Haskell list comprehensions as basically just a Cartesian/cross product machine? Would this be accurate? And then the combinatorics product rule also seems at play here. I would appreciate any theoretical explanation of what a list comprehension is about. ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 2

with -XOverloadedStrings, when is the implied fromString floated out?
by Johannes Waldmann 07 Dec '21

07 Dec '21

Dear Cafe, with OverloadedStrings, the compiler inserts `fromString` applications at String literals. I was wondering - are these floated out? {-# language OverloadedStrings #-} import Data.String import Debug.Trace data Foo = Foo deriving Show instance IsString Foo where fromString "Foo" = trace "**fromString**" Foo main = let { f Foo = "Foo" :: Foo; g _ = "Foo" :: Foo } in print $ map (f . g) [0..1] With ghc -O1, I get **fromString** [Foo,Foo] That's good - not just floated out, but also interned (? - both "Foo" are really the same, just one call) With ghc -00, and in ghci, I get **fromString** **fromString** **fromString** **fromString** [Foo,Foo] no floating here. Is there a way to get this floated in ghci? The background of my question is that overloaded strings, and ghci, are heavily used in Tidal Cycles https://hackage.haskell.org/package/tidal I guess it's mostly fine, because it's rare (in live coding performance) that application code contains function definitions. - J.

2 1

Re: [Haskell-cafe] Endo a, endomorphisms
by Olaf Klinke 07 Dec '21

07 Dec '21

> it might be possible that the intention was > to state that function composition is an endomorphism of the set of endofunctions (Endo a). > So again, given that the context is the Data.Monoid library, it seems much more appropriate to > say that Endo a forms a monoid of endofunctions under composition. As the examples I presented > above show, even stating that function composition is an endomorphism of Endo a (endofunctions) > seems incorrect. > What you write does not even type-check: Composition is an operation (b -> c) -> (a -> b) -> (a -> c) so it is a binary operation. Hence it cannot form an endomorphism, because you can't unify the above type with (x -> x). No ambiguity here. > opening :: String -> String > opening = ("Hello, " ++) > > closing :: String -> String > > closing = (++ "!") > > eo = Endo opening > > ec = Endo closing This is a manifestation of the fact that every monoid has a function a -> Endo a given by \a -> Endo (mappend a) This is indeed a monoid homomorphism (by virtue of associativity). Your 'eo' is of this kind. But then you mixed in another monoid homomorphism, namely \a -> Endo (flip mappend a) where your 'ec' is of this kind. It is not true in general that you can mix these two monoid homomorphisms. Only for commutative monoids the above two homomorphisms are identical. And (String,++) is not commutative. Indeed we could not give a Monoid instance to naked (a -> a) because it overlaps with the Semigroup instance you mention. But historically this is not the reason why the Endo newtype was introduced. One could argue that the Semigroup instance should also be on a newtype. I'd be in favour of such a proposal. Olaf P.S.: Let S be a functor (a signature) and a be an S-algebra, that is, there is a structure map alpha :: S a -> a. Then for any r, the type (r -> a) is an S-algebra, too. Indeed, alpha' :: Functor s => (s a -> a) -> s (r -> a) -> r -> a alpha' alpha sf = \r -> alpha (fmap ($x) sf) This is what makes the ReaderT transformer work. For Semigroup, the signature is S a = (a,a) and alpha = uncurry (<>).

1 0

Endo a, endomorphisms
by Adrian 05 Dec '21

05 Dec '21

In the Data.Monoid library there is a monoid type instance for Endo a that is described in the following manner: > The monoid of endomorphisms under composition. I understand how it is a monoid of endofunctions, but am unclear on how it is a monoid of endomorphisms. In the pattern: "forms a monoid of X under Y", X refers to the set and Y to the associative binary operation. So it seems that X in this case is the set of endofunctions. However, it might be possible that the intention was to state that function composition is an endomorphism of the set of endofunctions (Endo a). However even this statement seems difficult to prove in Haskell: opening :: String -> String opening = ("Hello, " ++) closing :: String -> String closing = (++ "!") eo = Endo opening ec = Endo closing appEndo (Endo $ opening <> closing) "Haskell" -- "Hello, HaskellHaskell!" (appEndo eo <> appEndo ec) "Haskell" -- "Hello, HaskellHaskell!" appEndo (eo <> ec) "Haskell -- "Hello, Haskell!" (opening <> closing) "Haskell" -- "Hello, HaskellHaskell!" (opening . closing) "Haskell" -- "Hello, Haskell!" I believe the reason for this behavior is that the fallback for mappend for the general endofunction with type a -> b is found in the Base library as: -- @since 4.9.0.0 instance Semigroup b => Semigroup (a -> b) where f <> g = \x -> f x <> g x

3 7

Output order of Data.List.permutations?
by Johannes Waldmann 05 Dec '21

05 Dec '21

Dear Cafe - what is the ordering of the output of https://hackage.haskell.org/package/base-4.16.0.0/docs/src/Data.OldList.htm… - and why is it not lexicographic? E.g., *Main> last $ L.permutations [1..8] [5,3,6,2,7,1,8,4] note: [5,_,6,_,7,_,8,_] and [_,3,_,2,_,1,_,4] indeed, an auxiliary function is called "interleave". Data.List.permutations appeared in base-4.0.0.0 (ghc-6.10.1, 2008) https://downloads.haskell.org/~ghc/6.10.1/docs/html/users_guide/release-6-1… What is the source of the algorithm? Is it any of the algorithms in Knuth AOCP 4A(I) 7.2.1.2? Hard to tell - as they are given in an imperative style. The implementation *is* fast, e.g., L.sort . L.permutations seems better than a naive lexicographic enumeration lp1 [] = [[]] lp1 xs = do (ys, z:zs) <- zip (L.inits xs) (L.tails xs) (z:) <$> lp1 (ys <> zs) (un-scientifically measured with :set +s) Here, clearly, L.inits and "<>" are bad. NB - I was looking in to this because of https://www.mathekalender.de/wp/calendar/challenges/challenge-01/ Yes I know that can be solved without enumeration. - J.

1 2

ANN: NASA's ogma
by Ivan Perez 03 Dec '21

03 Dec '21

Dear café We are thrilled to announce the release of Ogma, a new open-source NASA tool, written in Haskell, to generate hard-realtime C runtime monitoring applications from high-level specifications. Ogma takes the output of existing tools, like NASA's requirements elicitation tool FRET [2], and produces monitors in Copilot [3], a runtime verification language that can be compiled to hard-realtime C99. Ogma is also able to produce monitoring applications for NASA's Core Flight System (cFS), which can be compiled alongside existing applications to flag requirement violations. On the website you will see several videos, including one with a FRET requirement being monitored inside the XPlane flight simulator by taking the code generated by Ogma and making it accessible to the simualtor via a custom on-screen plugin. This is research-only software (Class E) and it has not been certified for use in aircraft or UAVs. We are currently using it for upcoming experiments at NASA Langley. We'd like to also take this opportunity to publicly thank the team that creates BNFC, for their tool, their response to technical questions during the development of ogma, and for accommodations made to help us speed up our release process. If you have any issues, feel free to open a ticket in the github repo directly. Happy haskelling, [1] https://github.com/NASA/ogma [2] https://github.com/NASA-SW-VnV/fret [3] https://github.com/Copilot-Language/copilot

1 0

Why and How the External STG Interpreter is Useful (Online presentation, Dec 2, Thursday, 17:00 UTC)
by Csaba Hruska 03 Dec '21

03 Dec '21

Hello, Today I'll do a presentation about the external stg interpreter. If you are interested please join and ask questions. https://skillsmatter.com/meetups/13654-haskell-stg-interp Regards, Csaba Hruska Abstract: Haskell: Why and How the External STG Interpreter is Useful The external STG interpreter is a from scratch implementation of the STG machine in Haskell. Currently it supports almost all GHC primops and RTS features. It can run real world Haskell programs that were compiled with GHC Whole Program Compiler (GHC-WPC). GHC-WPC is a GHC fork that exports the whole program STG IR. The external STG interpreter is an excellent tool to study the runtime behaviour of Haskell programs, i.e. it can run/interpret GHC or Pandoc. The implementation of the interpreter is in plain simple Haskell, so it makes compiler backend and tooling development approachable for everyone. It already has a programmable debugger which supports step-by-step evaluation, breakpoints and execution region based inspection. It also can export the whole program memory state and call-graphs to files for further investigation. These features make it easy to find a memory leak or to identify a performance bottleneck in a large real world Haskell application. https://github.com/grin-compiler/ghc-whole-program-compiler-project

1 1

Re: [Haskell-cafe] Breaking change to Eq accepted by Core Libraries Committee
by Olaf Klinke 03 Dec '21

03 Dec '21

For what it's worth, one of the examples listed in the issue where (/=) is not simply the negation of (==) is violating the laws. It is the one in https://hackage.haskell.org/package/numbers-3000.2.0.2/docs/Data-Number-Int… That module defines two intervals to be equal if their bounds are equal, but to be unequal only if they are disjoint. In my eyes this speaks for the proposal, because the library author would have been unable to write the broken instance. (And I did look at the proposal some time ago, whence I feel it was indeed discussed or at least mentioned on this list before.) Olaf

6 7

Trends in Functional Programming in Education 2022 2nd call for submissions
by Elena Machkasova 03 Dec '21

03 Dec '21

TFPIE 2022 Call for papers https://wiki.tfpie.science.ru.nl/TFPIE2022 (February 11th 2022, Krakow, Poland co-located with TFP 2022 and Lambda Days) TFPIE 2022 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: FP and beginning CS students FP and Computational Thinking FP and Artificial Intelligence FP in Robotics FP and Music Advanced FP for undergraduates FP in graduate education Engaging students in research using FP FP in Programming Languages FP in the high school curriculum FP as a stepping stone to other CS topics FP and Philosophy The pedagogy of teaching FP FP and e-learning: MOOCs, automated assessment etc. Best Lectures - more details below In addition to papers, we are requesting best lecture presentations. What's your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. The length of the presentation should be comparable to that of a paper. In addition, the speaker can provide commentary on effectiveness or student feedback. Submissions Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 20 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website. Papers and abstracts can be submitted via easychair at the following link: https://easychair.org/conferences/?conf=tfpie2022 After the workshop, presenters are invited to submit (a revised version of) their article for the formal review. The PC will select the best articles for publication in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. Important Dates Submission deadline: January 5th 2022, Anywhere on Earth. Notification: January 10th 2022 (Note: earlier submissions will receive earlier response) TFPIE Registration Deadline: TBA Workshop: February 11th 2022 Submission for formal review: April 15th 2022, Anywhere on Earth. Notification of full article: June 1st 2022 Camera ready: July 1st 2022 Program Committee Peter Achten, Radboud University, Netherlands Stephen Chang, University of Massachusetts Boston, USA John Hughes, Chalmers University of Technology, Sweden Elena Machkasova (Chair) - University of Minnesota Morris, USA Kristina Sojakova - INRIA, Paris, France Melinda Tóth, Eötvös Loránd University, Budapest, Hungary Keynote speaker Our keynote talk is "The perfect Functional Programming course" by Peter Achten. Registration information This year TFPIE takes place on the second day of the Lambda Days, concurrent with TFP. Participants will need to register for the Lambda Days. Please note that TFP and TFPIE have in-person attendance only. For registration fee, the deadlines, and the link to register see the Lambda Days web site: https://www.lambdadays.org/lambdadays2022 Registration and attendance are mandatory for at least one author of every paper that is presented at the workshop. Presenters will have their registration fee waived. Only papers that have been presented at TFPIE may be submitted to the post-reviewing process. Best regards, 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

Call for Haskell.org Committee Nominations
by Ida Bzowska 02 Dec '21

02 Dec '21

Hey, The Haskell.org Committee is looking for members. Maybe this is you or someone from your friends? Please read this post https://discourse.haskell.org/t/call-for-haskell-org-committee-nominations/… and drop us a line. λCheers Ida Bzowska

1 0

10 PhD studentships in Nottingham
by Graham Hutton 02 Dec '21

02 Dec '21

Dear all, The School of Computer Science at the University of Nottingham in the UK is seeking applications for 10 fully-funded PhD studentships: https://tinyurl.com/ten-phd-2021 Applicants in the area of the Functional Programming Lab (tinyurl.com/fp-notts) are strongly encouraged! If you are interested in applying, please contact a potential supervisor as soon as possible; the application deadline is 13th Feb: Thorsten Altenkirch - constructive logic, proof assistants, homotopy type theory, category theory, lambda calculus. Graham Hutton - functional programming, haskell, category theory, program verification, program calculation. Nicolai Kraus - homotopy type theory, higher category theory, constructive mathematics, and related topics. The studentships are open to applicants of any nationality. Best wishes, Graham Hutton +-----------------------------------------------------------+ 10 Fully-Funded PhD Studentships School of Computer Science University of Nottingham, UK tinyurl.com/ten-phd-2021 Applications are invited from international and home students for 10 fully-funded PhD studentships offered by the School of Computer Science, starting on 1st October 2022. The topics for the studentships are open, but should relate to interests of one of the School's research groups: Computational Optimisation and Learning; Computer Vision; Cyber Security; Functional Programming; Intelligent Modelling and Analysis; Mixed Reality; Uncertainty in Data and Decision Making. The studentships are fully-funded for 3.5 years and include a stipend of £15,009 per year and tuition fees. Applicants are normally expected to have a first class bachelors or masters degree in Computer Science or another relevant area, and must obtain the support of a potential supervisor in the School prior to submitting their application. If you are interested in applying, please contact a potential supervisor as soon as possible, and at least two weeks prior to the closing date. If the supervisor wishes to support your application, they will direct you to make an official application through the MyNottingham system. Closing date for applications: Sunday 13th February 2022. +-----------------------------------------------------------+ 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.24
by Simon Michael 02 Dec '21

02 Dec '21

I am pleased to announce hledger 1.24! https://hledger.org/release-notes.html#hledger-1-24 Highlights include new report layout options with less eliding, hledger-ui mouse support, and many fixes and improvements. Thank you to release contributors Stephen Morgan, toonn, Pranesh Prakash, Dmitry Astapov, ShrykeWindgrace, Joaquin Azcarate, and Lawrence Wu. hledger (https://hledger.org) is a dependable, cross-platform "plain text accounting" tool, with command-line, terminal and web interfaces. It is an actively maintained, largely compatible reimplementation of Ledger CLI with many improvements. You can use it to track money, time, investments, cryptocurrencies, inventory and more. See also the Plain Text Accounting site (https://plaintextaccounting.org) https://hledger.org/download shows all the ways to install hledger on mac, windows or unix (stack, cabal, brew, nix, CI binaries, your package manager..). Or, run this bash script to install or upgrade to the latest release: $ curl -sO https://raw.githubusercontent.com/simonmichael/hledger/master/hledger-insta… $ less hledger-install.sh # security review $ bash hledger-install.sh New users, check out https://hledger.org/quickstart or the tutorials (with pictures) at hledger.org -> FIRST STEPS or the https://hledger.org/videos.html. To get help, see https://hledger.org#help, and join our chat via Matrix: - #hledger:matrix.org (http://matrix.hledger.org) or Libera (they are bridged): - #hledger:libera.chat (http://irc.hledger.org) Beginners and experts, contributors, sponsors, and all feedback are most welcome. Wishing you health and prosperity, -Simon

1 0

What is Data.Vec.DataFamily.SpineStrict.Pigeonhole and why is it following me?
by Galaxy Being 01 Dec '21

01 Dec '21

Spam detection software, running on the system "mail.haskell.org", has identified this incoming email as possible spam. The original message has been attached to this so you can view it (if it isn't spam) or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: This <https://hackage.haskell.org/package/vec-0.4/docs/Data-Vec-DataFamily-SpineS…> in Hackage is something a rank amateur like me can't fathom. I just hit a chapter in a book that dives into the Pigeonhole Principle. Is this the "accompanying Haskell Wundercode" for the math world's PHP? I know PHP is a big deal in math. I don't see an "author," and I see no documentation. Anyone know how I can figure this mystery out, like at least find the author or someone that knows something about this? [...] Content analysis details: (5.0 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 FREEMAIL_FROM Sender email is commonly abused enduser mail provider (borgauf[at]gmail.com) -0.0 SPF_PASS SPF: sender matches SPF record -0.0 BAYES_40 BODY: Bayes spam probability is 20 to 40% [score: 0.3039] 5.0 UNWANTED_LANGUAGE_BODY BODY: Message written in an undesired language 0.0 HTML_MESSAGE BODY: HTML included in message 0.0 T_DKIM_INVALID DKIM-Signature header exists but is not valid The original message was not completely plain text, and may be unsafe to open with some email clients; in particular, it may contain a virus, or confirm that your address can receive spam. If you wish to view it, it may be safer to save it to a file and open it with an editor.

3 2

MonadFail with type parameter for error message
by Daneel Yaitskov 30 Nov '21

30 Nov '21

Dear Cafe, MonadFail.fail takes String. I wasn't able to find MonadFail for custom error type. Is there any proposals to base? Let's say Data.Text, which gains popularity with OverloadedStrings extensions. class MonadFail m where fail :: String -> m a Why not ? class MonadFail m where fail :: (forall s. IsString s => s) -> m a class MonadFailWith m s where fail :: s -> m a -- Best regards, Daniil Iaitskov

3 3

Re: [Haskell-cafe] methods/tools for reading/presenting (time/allocation) profiling information?
by Olaf Klinke 27 Nov '21

27 Nov '21

> Dear Cafe, > > with +RTS -p -RTS, the resulting .prof file > shows (in the second part) what the expensive functions are. > (counting sections as GHC docs do - > first part gives program name and options) > > Often, that's useful, but sometimes, this info does not surprise me - > some things just don't have an easy implementation. > For those, I want to find out who calls them - > to possibly replace some of these calls > with a cheaper implementation (that is only valid > because the caller knows something that the callee does not) > > Is there some automation for getting this information? > I am not even sure how to formalize what I want. > Perhaps, for the first N heavy cost centers (SCCs), > a suitably ordered list of their callers (that inherit the cost)? > > The data is in the third (long, detailed) part of the .prof file > but I find it hard to process (in that form). It represents > the call hiearchy by indentation (first column) and adjacency (of rows) > but this goes out the window as soon as I grep or sort the rows. > > The JSON output format seems the way to go > https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.h… > . > Yeah, I should probably just aeson it and then walk the tree. > I still wanted to ask for advice first, or references > to existing work. Any pointers appreciated. > > - J. > Profiteur has served me well in this regard. It shows me what top-level functions eat most of the execution times, and which sub-functions have the biggest share thereof, etc. All in a nice interactive browser interface. https://hackage.haskell.org/package/profiteur Olaf

1 0

methods/tools for reading/presenting (time/allocation) profiling information?
by Johannes Waldmann 26 Nov '21

26 Nov '21

Dear Cafe, with +RTS -p -RTS, the resulting .prof file shows (in the second part) what the expensive functions are. (counting sections as GHC docs do - first part gives program name and options) Often, that's useful, but sometimes, this info does not surprise me - some things just don't have an easy implementation. For those, I want to find out who calls them - to possibly replace some of these calls with a cheaper implementation (that is only valid because the caller knows something that the callee does not) Is there some automation for getting this information? I am not even sure how to formalize what I want. Perhaps, for the first N heavy cost centers (SCCs), a suitably ordered list of their callers (that inherit the cost)? The data is in the third (long, detailed) part of the .prof file but I find it hard to process (in that form). It represents the call hiearchy by indentation (first column) and adjacency (of rows) but this goes out the window as soon as I grep or sort the rows. The JSON output format seems the way to go https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.h… . Yeah, I should probably just aeson it and then walk the tree. I still wanted to ask for advice first, or references to existing work. Any pointers appreciated. - J.

2 1

Logging
by Olaf Klinke 22 Nov '21

22 Nov '21

Dear Hilco, attached is a module we use in production. It builds on top of the monad-logger package which is used, among other places, in Yesod. Olaf

1 0

Re: [Haskell-cafe] Logging
by Olaf Klinke 22 Nov '21

22 Nov '21

As someone who works with timeseries for a living, I can say that what is a nightmare is timestamps that do not correspond to a unique UTC time. So you'd want a ZonedTime timestamp. I've been using monad-logger and rolled my own extension which adds (formatted) time stamps to the log messages. Olaf

1 0

Locate errors in TH for Haskell code
by Anton Kholomiov 21 Nov '21

21 Nov '21

I have a task to convert one Haskell expression to another. And I'd like to report errors properly. [interpret| -- error reported here valid haskell code invalid code <- error |] I can parse it with haskell-src-exts or haskell-src-meta. but if I have error in the code (type-check) error is positioned on the first line of the QQ-expression. Do you know is it possible to report error at the line where it has happened or to keep original source code location in the Exp. In the function I do transformation Exp -> Exp. Or maybe there is a better way to do it instead of QQ?

4 4

Re: [Haskell-cafe] code in postings mangled?
by Olaf Klinke 19 Nov '21

19 Nov '21

> Why is code in postings so often mangled: > Seems it is only the linebreaks. Some programs on Windows, including TextEdit and likely your mail client, don't consider a newline '\n' character to be a line break, since Windows terminates lines by "\r\n". Then OS X has '\r' line terminators, which again might not be considered a linebreak on some systems. I remember all kinds of stupid things arising from this, including version control systems flagging every line as changed when it was only the line breaks. I read this list as digest, so I can not verify using the particular raw email you quoted. Can someone else check this? Regards, Olaf

2 1

Partial record access
by Georgi Lyubenov 19 Nov '21

19 Nov '21

Hey Cafe, With the advent of RecordDotSyntax (or more precisely OverloadedRecordDot?) in 9.2, I was expecting this wart to be fixed: data Ty = X {x :: String} | Y {y :: Int} > y $ X "lol" *** Exception: No match in record selector y As it seems like the perfect opportunity to introduce a breaking change for a behaviour that is usually undesirable (in my experience). But instead: > :set -XOverloadedRecordDot > (X "lol").y *** Exception: No match in record selector y Unfortunately, I couldn't follow and/or remember all of the discussion around RecordDotSyntax, so this might be something I missed. Is there a reason why we don't generate HasField x r a only when all of the constructors for r have a field "x" :: a? If not, is the community open to changing this, while the new extension is still ripe? Cheers! ======= Georgi

2 2

[ANN] Release candidate for `mtl-2.3`
by Emily Pillmore 19 Nov '21

19 Nov '21

Hello all, Chessai and I are excited to announce a release candidate for `mtl`: [`mtl-2.3-rc3`]( https://github.com/haskell/mtl/releases/tag/v2.3-rc3 )! ## Timeline The timeline for release will be as follows: - This announcement marks the start of the timeline - We will give 2 weeks of testing before considering release - If no major issues are filed before then, `mtl-2.3-rc3` will be released as `mtl-2.3`, and if issues are found, they will be amended, and a new release candidate will be announced, resetting the 2 week period. To test `mtl-2.3-rc3` for yourself, please feel free to add the following to your `cabal.project`: ``` source-repository-package type: git location: https://github.com/haskell/mtl.git tag: 5d0f62b8007bb96e49f36a5544741cfe96a97130 ``` or, if you're a stack user add this entry to your `extra-deps`: ``` - git: https://github.com/haskell/mtl.git commit: 5d0f62b8007bb96e49f36a5544741cfe96a97130 ``` And make sure to adjust all bounds/`allow-newer` accordingly. Please note that this release of `mtl` is a full major version release, and *will be the last of the 2.x series before work begins on updating the mtl class hierarchy*. ## Changelog * Add instances for `Control.Monad.Trans.Writer.CPS` and `Control.Monad.Trans.RWS.CPS` from `transformers` 0.5.6 and add `Control.Monad.Writer.CPS` and `Control.Monad.RWS.CPS`. * `Control.Monad.Cont` now re-exports `evalCont` and `evalContT` * Add `tryError`, `withError`, `handleError`, and `mapError` to `Control.Monad.Error.Class`, and re-export from `Control.Monad.Except`. * Remove `Control.Monad.List` and `Control.Monad.Error` * Remove instances of deprecated `ListT` and `ErrorT` * Remove re-exports of `Error` * Add instances for `Control.Monad.Trans.Accum` and ` Control.Monad.Trans.Select ( http://control.monad.trans.select/ ) ` * Remove re-exports of `Control.Monad`, `Control.Monad.Fix` and `Data.Monoid` modules I'd like to thank the many contributors who offered patches, tickets, and other help in the preparation of this release. We appreciate all of your help! Happy hacking! Emily

1 0

[ANNOUNCE] GHC 9.2.1 now available
by Ben Gamari 18 Nov '21

18 Nov '21

Hi all, The GHC developers are very happy to at long last announce the availability of GHC 9.2.1. Binary distributions, source distributions, and documentation are available at https://downloads.haskell.org/ghc/9.2.1 GHC 9.2 brings a number of exciting features including: * A native code generation backend for AArch64, significantly speeding compilation time on ARM platforms like the Apple M1. * Many changes in the area of records, including the new `RecordDotSyntax` and `NoFieldSelectors` language extensions, as well as Support for `DuplicateRecordFields` with `PatternSynonyms`. * Introduction of the new `GHC2021` language extension set, giving users convenient access to a larger set of language extensions which have been long considered stable. * Merging of `ghc-exactprint` into the GHC tree, providing infrastructure for source-to-source program rewriting out-of-the-box. * Introduction of a `BoxedRep` `RuntimeRep`, allowing for polymorphism over levity of boxed objects (#17526) * Implementation of the `UnliftedDataTypes` extension, allowing users to define types which do not admit lazy evaluation ([proposal]) * The new [`-hi` profiling] mechanism which provides significantly improved insight into thunk leaks. * Support for the `ghc-debug` out-of-process heap inspection library [ghc-debug] * Significant improvements in the bytecode interpreter, allowing more programs to be efficently run in GHCi and Template Haskell splices. * Support for profiling of pinned objects with the cost-centre profiler (#7275) * Faster compilation and a smaller memory footprint * Introduction of Haddock documentation support in TemplateHaskell (#5467) 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 testing, - Ben [apple-m1]: https://www.haskell.org/ghc/blog/20210309-apple-m1-story.html [proposal]: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0265-u… [-hi profiling]: https://well-typed.com/blog/2021/01/first-look-at-hi-profiling-mode/ [ghc-debug]: http://ghc.gitlab.haskell.org/ghc-debug/ [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

3 2

type checking failure curiosity
by Julian Bradfield 18 Nov '21

18 Nov '21

In the course of updating a tutorial for this year's course, I found the provided code didn't compile. This is because a key value is "undefined" in order for the students to fill it in, but I'm curious why it can't be typechecked nonetheless. The code is: reachable :: (Ord q) => FSM q -> Set(Set(q)) -> Set(Set(q)) reachable fsm@(FSM qs as ts ss fs) supers = let new :: Set(Set(q)) -- typechecking fails without this declaration new = undefined in if null new then supers else reachable fsm (supers \/ new) The \/ in the last line is just Set.union. On the face of it, the last term directly forces "new" to have type Set(Set(q)), so why doesn't Haskell see that? Without the explicit type declaration of "new", we get: • Could not deduce (Foldable t0) arising from a use of ‘null’ from the context: Ord q bound by the type signature for: reachable :: forall q. Ord q => FSM q -> Set (Set q) -> Set (Set q) at CLTutorial9.hs:127:1-60 The type variable ‘t0’ is ambiguous These potential instances exist: instance Foldable (Either a) -- Defined in ‘Data.Foldable’ instance Foldable Set -- Defined in ‘Data.Set.Internal’ instance Foldable Maybe -- Defined in ‘Data.Foldable’ ...plus two others ...plus 27 instances involving out-of-scope types (use -fprint-potential-instances to see them all) • In the expression: null new In the expression: if null new then supers else reachable fsm (supers \/ new) In the expression: let new = undefined in if null new then supers else reachable fsm (supers \/ new) | 130 | in if null new then supers else reachable fsm (supers \/ new) | ^^^^^^^^

4 5

code in postings mangled?
by Gregory Guthrie 17 Nov '21

17 Nov '21

Why is code in postings so often mangled: Subject: [Haskell-cafe] ContT and MonadSafe ... Then I implement this kind of method withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> (Dataset -> m r) -> m r withHdf5PathP loc (H5RootPath subpath) f = withHdf5PathP loc subpath f withHdf5PathP loc (H5GroupPath n subpath) f = withGroupP (openGroup loc n Nothing) $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5GroupAtPath i subpath) f = withGroupAtP loc i $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5DatasetPath n) f = withDatasetP (openDataset' loc n Nothing) f withHdf5PathP loc (H5DatasetPathAttr (a, c)) f = withDatasetP (openDatasetWithAttr loc a c) f withHdf5PathP loc (H5Or l r) f = withHdf5PathP loc l f `catchAll` const (withHdf5PathP loc r f) I decided to switch to the ContT transfomer and try to implement this like this withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> ContT r m Dataset withHdf5PathP loc (H5RootPath subpath) = withHdf5PathP loc subpath withHdf5PathP loc (H5GroupPath n subpath) = do g <- withGroupP (openGroup loc n Nothing) withHdf5PathP g subpath withHdf5PathP loc (H5GroupAtPath i subpath) = do g <- withGroupAtP loc i withHdf5PathP g subpath withHdf5PathP loc (H5DatasetPath n) = withDatasetP (openDataset' loc n Nothing) withHdf5PathP loc (H5DatasetPathAttr (a, c)) = withDatasetP (openDatasetWithAttr loc a c) withHdf5PathP loc (H5Or l r) = ???

2 1

ContT and MonadSafe
by PICCA Frederic-Emmanuel 16 Nov '21

16 Nov '21

Hello, I have some code like this data Hdf5Path sh e = H5RootPath (Hdf5Path sh e) | H5GroupPath ByteString (Hdf5Path sh e) | H5GroupAtPath Int (Hdf5Path sh e) | H5DatasetPath ByteString | H5DatasetPathAttr (ByteString, ByteString) | H5Or (Hdf5Path sh e) (Hdf5Path sh e) deriving (Show) Then I implement this kind of method withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> (Dataset -> m r) -> m r withHdf5PathP loc (H5RootPath subpath) f = withHdf5PathP loc subpath f withHdf5PathP loc (H5GroupPath n subpath) f = withGroupP (openGroup loc n Nothing) $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5GroupAtPath i subpath) f = withGroupAtP loc i $ \g -> withHdf5PathP g subpath f withHdf5PathP loc (H5DatasetPath n) f = withDatasetP (openDataset' loc n Nothing) f withHdf5PathP loc (H5DatasetPathAttr (a, c)) f = withDatasetP (openDatasetWithAttr loc a c) f withHdf5PathP loc (H5Or l r) f = withHdf5PathP loc l f `catchAll` const (withHdf5PathP loc r f) I decided to switch to the ContT transfomer and try to implement this like this withHdf5PathP :: (MonadSafe m, Location l) => l -> Hdf5Path sh e -> ContT r m Dataset withHdf5PathP loc (H5RootPath subpath) = withHdf5PathP loc subpath withHdf5PathP loc (H5GroupPath n subpath) = do g <- withGroupP (openGroup loc n Nothing) withHdf5PathP g subpath withHdf5PathP loc (H5GroupAtPath i subpath) = do g <- withGroupAtP loc i withHdf5PathP g subpath withHdf5PathP loc (H5DatasetPath n) = withDatasetP (openDataset' loc n Nothing) withHdf5PathP loc (H5DatasetPathAttr (a, c)) = withDatasetP (openDatasetWithAttr loc a c) withHdf5PathP loc (H5Or l r) = ??? during the process, I also changed all the withXXX method to use Continuation. -bracket' :: MonadSafe m => (a -> IO ()) -> IO a -> (a -> m r) -> m r -bracket' r a = bracket (liftIO a) (liftIO . r) +bracket' :: MonadSafe m => (a -> IO ()) -> IO a -> ContT r m a +bracket' r a = ContT (bracket (liftIO a) (liftIO . r)) -withBytes :: MonadSafe m => Int -> (ForeignPtr a -> m r) -> m r +withBytes :: MonadSafe m => Int -> ContT r m (ForeignPtr a) withBytes n = bracket' touchForeignPtr (mallocForeignPtrBytes n) -withFileP :: MonadSafe m => IO File -> (File -> m r) -> m r +withFileP :: MonadSafe m => IO File -> ContT r m File withFileP = bracket' closeFile -withGroupP :: MonadSafe m => IO Group -> (Group -> m r) -> m r +withGroupP :: MonadSafe m => IO Group -> ContT r m Group withGroupP = bracket' closeGroup -withGroupAtP :: (Location l, MonadSafe m) => l -> Int -> (Group -> m r) -> m r -withGroupAtP l i f = do +withGroupAtP :: (Location l, MonadSafe m) => l -> Int -> ContT r m Group +withGroupAtP l i = do es <- liftIO $ nxEntries' l - withGroupP (openGroup l (es !! i) Nothing) f + withGroupP (openGroup l (es !! i) Nothing) -withDatasetP :: MonadSafe m => IO Dataset -> (Dataset -> m r) -> m r +withDatasetP :: MonadSafe m => IO Dataset -> ContT r m Dataset withDatasetP = bracket' closeDataset -withDataspaceP :: MonadSafe m => IO Dataspace -> (Dataspace -> m r) -> m r +withDataspaceP :: MonadSafe m => IO Dataspace -> ContT r m Dataspace withDataspaceP = bracket' closeDataspace The H5Or is a sort of Alternative which try to extract the info from l and if any exception is triggered switch to the right part r. Would you be so kind to help me write the H5Or part with the continuation. I am not sure that I understand all the ContT arcanes. thanks for your help Frederic

2 2

haskell-ci problems
by Sven Panne 16 Nov '21

16 Nov '21

I am (finally) about to switch my Haskell projects on GitHub from Travis CI to GitHub Actions, so I've tried haskell-ci (from HEAD) for creating the workflow files from the .cabal files. But something went wrong, see https://github.com/haskell-opengl/StateVar/actions/runs/1456427818/workflow Initially, I thought that this failure was related to using the latest and greatest GHC version, so I removed that, but the failure stays: https://github.com/haskell-opengl/StateVar/actions/runs/1456437461/workflow Any hints on what I'm doing wrong? Or is it a haskell-ci bug? Cheers, S.

4 10

About adding msync and anonymous mapping (virtual allocation) API to mmap package
by YueCompl 15 Nov '21

15 Nov '21

Dear Gracjan Polak, and Cafe for wider attention, I'm using the great [mmap](https://hackage.haskell.org/package/mmap <https://hackage.haskell.org/package/mmap>) package, and now I need 2 more features closely related to its existing features: - API to perform `msync` so as for: - A long running process to checkpoint the persistence of modifications - Parallel readers to see other writer's modification with cache coherence, i.e. invalidate cache as notified - API to do anonymous mmap-ping for volatile (virtual) memory allocation I expect the coding work to be trivial and intend to do it myself, however it's better to ask your opinion meanwhile I experiment with the ideas. Would you like to accept such features into [mmap] package? How do you think about details of such features? For the background of my needs: I'm working on a shared immutable heap implementation, persistency will be provided by disk backed storage servers, parallel work horse servers will build heap contents in rather coarse grained fashion, first as volatile heaps in one's private memory, then publish into shared storage with bulk writing, so all servers will be able to mmap such public heaps into their own memory address space, with kernel pages as cache shared by all processes on a same physical node. I hope it's okay to ask in the Cafe list at the same time, as I also anticipate more feedbacks/opinions from the list with broader expertise, will much appreciate! Thanks with best regards, Compl

1 0

Breaking change to Eq accepted by Core Libraries Committee
by Rune K. Svendsen 15 Nov '21

15 Nov '21

Dear list, I would like to bring attention to the fact that the Haskell “Core Libraries Committee” has just accepted a breaking change to the Eq type class in exchange for very little apparent benefit. Please use this GitHub issue to voice your opinion on the issue: https://github.com/haskell/core-libraries-committee/issues/3 I don’t think it’s been sufficiently discussed yet. /Rune

4 3

clz / bsr functions on Integer
by james faure 13 Nov '21

13 Nov '21

Why is there no `countLeadingZeros` function for Integer? This seems particularly strange because gmp provides mp_bitcnt_t mpz_scan0 (const mpz_t op, mp_bitcnt_t starting_bit) More importantly, what is the recommended way to access it?

4 3

Should circular deriving "via" be rejected?
by Viktor Dukhovni 12 Nov '21

12 Nov '21

GHC accepts: {-# LANGUAGE DerivingStrategies, DerivingVia #-} newtype Foo = Foo Int deriving (Show, Eq) via (Bar) newtype Bar = Bar Int deriving (Show, Eq) via (Foo) should there be any effort to avoid circular definitions? Of course one could always implement an explicit `show` method that diverges, so perhaps this is no worse, but on the other hand, statically deciding divergence looks potentially easier in this case... On the other hand actual definitions like this seem unlikely in practice, so perhaps not worth burning precious compiler cycles to detect them? -- Viktor.

2 1

Want to join a Team and Looking for good first issues to contribute
by Hima Bindu 11 Nov '21

11 Nov '21

Hi There! I am Hima Bindu, a CS Undergrad in GVPCE(A), AP, India. I like to be a polyglot and started learning a few languages, and came across Haskell. I was fascinated by its laziness and learned it for a couple of months. I skimmed through the repos, GSoC projects and a few Twitter threads. I want to contribute to anything that is beginner-friendly. It's overwhelming but I want to give it a try. Looking for any kind of suggestions or a walkthrough. This is very new to me, so please feel free to point out if I'm doing something wrong or moving in the wrong direction. *My area of interests:* Compilers(Currently working on one by following Bob Nystrom's book), Operating Systems/Kernals(have no experience but interested), anything related specifically to Haskell language(Data Structures, error handling etc) *Also, I eagerly want to join monthly meetings or something of that sort if there are any. How can I do that?* Really looking forward to your replies. Thank you Have a good day :D -- *Hima Bindu Tenneti* *Reach me here! <https://portfolios.talentsprint.com/~hima_bindu/>* *Programs must be written for people to read, and only incidentally for machines to execute. --Hal Abelson, SICP*

1 0

[meetup announcement] Haskell Utrecht Meetup Group
by Ida Bzowska 10 Nov '21

10 Nov '21

Hi Everyone, Just letting you know that the freshly formed Haskell meetup from the Netherlands will have the first meetup on the 22nd of Nov; if you are in the area - don't hesitate: come! https://www.meetup.com/haskell-utrecht/events/281978445/ λCheers Ida Bzowska

1 0

[ANN] linear-generics-0.2
by David Feuer 09 Nov '21

09 Nov '21

This new major version improves the GHCGenerically1 DerivingVia target. Previously, it worked on strictly fewer types than GHC could derive Generic1 for. Now it works on strictly more types than that. It does this by using a derived Generic instance instead of a derived Generic1 instance, thanks to the magic of quantified constraints. For anyone already using the package, the upgrade path is trivial: just derive any additional Generic instances GHC asks for.

1 0

Re: [Haskell-cafe] Locate errors in TH for Haskell code
by Michal J Gajda 07 Nov '21

07 Nov '21

Dear Anton, > I have a task to convert one Haskell expression to another. > And I'd like to report errors properly. > > [interpret| -- error reported here > valid haskell code > invalid code <- error > |] > > I can parse it with haskell-src-exts or haskell-src-meta. > but if I have error in the code (type-check) error is positioned on the > first line of the QQ-expression. > > Do you know is it possible to report error at the line where it has > happened or > to keep original source code location in the Exp. > > In the function I do transformation Exp -> Exp. > > Or maybe there is a better way to do it instead of QQ? QQ is a good way. The simplest way would be to use `Language.Haskell.TH.location :: Q Loc` [1] and update it with the `Language.Haskell.Exts.SrcLoc.Loc` you get from `haskell-src-exts`[2]. [1] https://hackage.haskell.org/package/template-haskell-2.18.0.0/docs/Language… [2] https://hackage.haskell.org/package/haskell-src-exts-1.23.1/docs/Language-H… Note that [1] is available since template-haskell version 2.8.0.0. -- Best regards Michał

1 0

ghc-9.2.1 unboxed types compatibility
by Bruno Damour 06 Nov '21

06 Nov '21

Hello, A significant number of libraries are broken by the changes in unboxed types. A lot of them are in the process (or already have) of adding compatibility layers to allow them to support the new version while preserving compatibility with older ones, introducing code like : #if MIN_VERSION_base(4,16,0) word32ToWordCompat# :: Word32# -> Word# word32ToWordCompat# = word32ToWord# #else word32ToWordCompat# :: Word32# -> Word# word32ToWordCompat# x = x #endif for the functions they use (usually a small subset). Some of the solutions appear to differ. Is there a preferred way to make this consistently or/and avoid unnecessary code duplication ? Thanks Bruno

4 4

printing unicode in Windows console: hPutChar error
by Julian Bradfield 06 Nov '21

06 Nov '21

Some of my poor misguided students are still using Windows, and when they run my (predecessor's) Haskell program which uses Unicode box drawing characters in its output, they get *** Exception <stdout>: hPutChar: invalid argument (invalid character) Another student told them to change the console encoding via magic: chcp.com 65001 but a bit of googling suggests that a "modern Windows console program" should be using the widechar API to print Unicode and things should Just Work. Does Haskell have a principled view about character encodings? Or does it just say "I do byte strings, it's the user's problem"? Decades ago I was all in favour of charset-agnosticism, but these days I tend to think "go Unicode, and leave the legacy Latin-1 etc. data as the user's problem" :) Julian. -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

4 5

Type inference for lambda function
by Matthias Güdemann 04 Nov '21

04 Nov '21

Hi cafe, today while explaining lambda functions I came across this case which I don't really understand. This is what I get using ghci λ> :t (\a b -> a + b) (\a b -> a + b) :: Num a => a -> a -> a but when loading a .hs file with just this function (without signature) add = \a b -> a + b I get λ> :t add add :: Integer -> Integer -> Integer but I can explicitly define add to have this type: add :: Num a => a -> a -> a add = \a b -> a + b Also ghc infers this polymorphic type for example for add0 a = \b -> a + b Why is the type of add without a signature inferred to Integer and not Num a? Best regards Matthias

6 11

TOP is hiring Functional Programmers for developing multi-user web applications
by rinus plasmeijer 03 Nov '21

03 Nov '21

Dear Haskell Fans, TOP Software Technology (top-software.com <http://top-software.com>) is a recently founded (2018) spin-off company located in the Netherlands, building on decades of research on Functional Programming at the Radboud University of Nijmegen (clean.cs.ru.nl <http://clean.cs.ru.nl>). By using advanced Functional Programming techniques and tools, we develop collaborative, distributed, multi-user / multi-system / multi-platform, web-oriented software applications for industry. We focus on Command and Control type of applications such as VIIA <https://top-software.nl/VIIA.html> <https://top-software.nl/VIIA.html> where real-time information is used for monitoring vessels. We use Clean, a Haskell like pure and lazy functional language, and the iTask system offering Task Oriented Programming (TOP), a special flavour of Functional Programming to construct reliable software applications for our customers at a high-level of abstraction on an Agile manner. We are looking for Experienced Functional Programmers to join our team. See the attached pdf. More information on what we do can be found ontop-software.com <http://top-software.com>. Mail torinus(a)top-software.com <mailto:rinus@top-software.com> orrinus(a)cs.ru.nl <mailto:rinus@cs.ru.nl> if you are interested. Greetings, Rinus Plasmeijer

1 0

[ANN] text-display 0.0.1.0: A typeclass for user-facing output
by Hécate 02 Nov '21

02 Nov '21

Hi everyone, I am proud to release the first version of text-display¹, a typeclass for user-facing output. `Display` is a typeclass that doesn't abide by the rules of `Show` & `Read`, and brings with it a nice and ergonomic way to derive instances through `DerivingVia` when they already have a `Show` instance: ```haskell {-# LANGUAGE DerivingVia #-} data AutomaticallyDerived = AD -- We derive 'Show' deriving Show -- We take advantage of the 'Show' instance to derive 'Display' from it deriving Display via (ShowInstance AutomaticallyDerived) ``` But let's say you want to redact an instance of `Display`? You can do it locally, through the `OpaqueInstance` helper. It is most useful to hide tokens or passwords: ```haskell data UserToken = UserToken UUID deriving Display via (OpaqueInstance "[REDACTED]" UserToken) display $ UserToken "7a01d2ce-31ff-11ec-8c10-5405db82c3cd" -- => "[REDACTED]" ``` I hope you will have fun with this library! Cheers! ¹ https://hackage.haskell.org/package/text-display-0.0.1.0 -- Hécate ✨ 🐦: @TechnoEmpress IRC: Hecate WWW: https://glitchbra.in RUN: BSD

2 1

Call for Contributions: BOB 2022 [March 11, Deadline Dec 6]
by Stefan Wehr 02 Nov '21

02 Nov '21

================================================================================ BOB Conference 2022 "What happens when we use what's best for a change?" http://bobkonf.de/2022/cfc.html Berlin, Mar 11 Call for Contributions Deadline: December 6, 2021 ================================================================================ 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"). Online or Onsite ---------------- We expect we'll be able to hold BOB 2022 in Berlin. If that is not possible, we'll make BOB a successful online event, like BOB 2021. Should BOB happen online, we will likely ask for pre-recorded talks to make room for questions and social interactions during the actual conference day. (Of course, we'll provide assistance making those recordings.) Tutorials will likely happen as a live-session. 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. 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, …) - Don't be confused: The system calls a submission event. Organisation ------------ - Direct questions to contact at bobkonf dot de - Proposal deadline: December 6, 2021 - Notification: December 17, 2021 - Program: December 22, 2021 Submit here: https://bobcfc.active-group.de/en/bob2022/cfp Program Committee ----------------- (more information here: https://bobkonf.de/2022/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

No "fields of ... not initialized" warning with RecordWildCards and Void?
by Markus Läll 02 Nov '21

02 Nov '21

Hi! Would it make sense to suppress the "fields of ... not initialized" when the type of the field is Void, or any other type with no data constructors? As the only way to construct void would be `undefined :: Void`, and the field already is undefined. Regards, -- Markus Läll

3 5

ghci's choice of names for type variables
by Julian Bradfield 01 Nov '21

01 Nov '21

I have tried to answer this by google and the list archives, but without success, though it wouldn't surprise me if there is a post buried somewhere. This is GHCI 8.10.7. When ghci infers types, it sometimes produces types with "a", with "t", and with "p" (and maybe others), as in the following set of examples: Prelude> h (x : xs) = x Prelude> :t h h :: [a] -> a Prelude> foo f x = not(f x) Prelude> :t foo foo :: (t -> Bool) -> t -> Bool Prelude> bar f x = (f x) + 1 Prelude> :t bar bar :: Num a => (t -> a) -> t -> a Prelude> barb f x g y = (f x)+(g y) Prelude> :t barb barb :: Num a => (t1 -> a) -> t1 -> (t2 -> a) -> t2 -> a Prelude> gar f x = f x Prelude> :t gar gar :: (t1 -> t2) -> t1 -> t2 Prelude> fooa x = x Prelude> :t fooa fooa :: p -> p What is its rationale? I have attempted to find it in the typechecker code, and I see things that suggest "t" is something to do with tau types (monotypes?), and "p" has something to do with levels, but going from basic Haskell and a modest theoretical acquaintance with System F to being able to read the GHCi type-checker is several steps too far! Can somebody give me a brief explanation of what's going on? In particular, is there actual information about the types in the choice of letters, or is it just incidental information about the way type inference proceeded? Thanks, Julian. -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

3 3

Trojan source
by Henning Thielemann 01 Nov '21

01 Nov '21

Hide malicious code behind Unicode with reversed text direction: https://github.com/nickboucher/trojan-source They are missing the Haskell examples.

2 1

German live interview about experiences with functional programming, today 12:00
by Henning Thielemann 01 Nov '21

01 Nov '21

https://www.heise.de/news/software-architektur-tv-Funktionale-Programmierun…

2 2

Journal of Functional Programming - Call For PhD Abstracts
by Graham Hutton 01 Nov '21

01 Nov '21

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

1 0

GHC 9.2.x error on m1 Mac?
by Stuart Hungerford 01 Nov '21

01 Nov '21

Hi, I've been trying out the latest GHC (9.2.1) on an m1 Mac running macOS 12.0.1. I'm seeing this error when building an existing project: Failed to build wcwidth-0.0.2. Build log ( /Users/stu/.cabal/logs/ghc-9.2.1/wcwdth-0.0.2-232d390d.log ): Warning: wcwidth.cabal:47:45: version operators used. To use version operators the package needs to specify at least 'cabal-version: >= 1.8'. Warning: wcwidth.cabal:30:45: version operators used. To use version operators the package needs to specify at least 'cabal-version: >= 1.8'. Configuring wcwidth-0.0.2... Preprocessing library for wcwidth-0.0.2.. Building library for wcwidth-0.0.2.. [1 of 1] Compiling Data.Char.WCWidth ( Data/Char/WCWidth.hs, dist/build/Data/Char/WCWidth.o, dist/build/Data/Char/WCWidth.dyn_o ) In file included from /var/folders/2q/ym4rpn7j6v9d6jhpt0wnk03r0000gn/T/ghc7111_0/ghc_3.c:4:0: error: In file included from /Users/stu/.ghcup/ghc/9.2.1/lib/ghc-9.2.1/lib/../lib/aarch64-osx-ghc-9.2.1/rts-1.0.2/include/ffi.h:66:0: error: /Users/stu/.ghcup/ghc/9.2.1/lib/ghc-9.2.1/lib/../lib/aarch64-osx-ghc-9.2.1/rts-1.0.2/include/ffitarget.h:6:10: error: fatal error: 'ffitarget_arm64.h' file not found | 6 | #include "ffitarget_arm64.h" | ^ #include "ffitarget_arm64.h" ^~~~~~~~~~~~~~~~~~~ 1 error generated. Am I missing a package or system library/header that provides that ffitarget_arm64.h file? TIA, Stu

2 4

New CLC proposal process
by Andrew Lelechenko 30 Oct '21

30 Oct '21

I'm happy to announce that Core Libraries Committee has completed post-election reboot and now has a new home at https://github.com/haskell/core-libraries-committee <https://github.com/haskell/core-libraries-committee> and a new GitHub-based process: https://github.com/haskell/core-libraries-committee/blob/main/PROPOSALS.md <https://github.com/haskell/core-libraries-committee/blob/main/PROPOSALS.md>. From now on proposals to change base should be raised as GitHub issues instead of emails to libraries@. Best regards, Andrew

1 0