From adam at well-typed.com  Wed Dec  1 08:41:26 2021
From: adam at well-typed.com (Adam Gundry)
Date: Wed, 1 Dec 2021 08:41:26 +0000
Subject: [Haskell-cafe] What is
 Data.Vec.DataFamily.SpineStrict.Pigeonhole and why is it following me?
In-Reply-To: <CAMgWh9s5FEGWqTRLnk1KCjechN7vFzoC-nQ6OwqfTsix0dr-4w@mail.gmail.com>
References: <CAFAhFSXUKNxBX4h1rDKMNrVQoPKEHVjYnNwZgjsbQuBNm2s8oA@mail.gmail.com>
 <CAMgWh9s5FEGWqTRLnk1KCjechN7vFzoC-nQ6OwqfTsix0dr-4w@mail.gmail.com>
Message-ID: <d8d1ebc9-5e01-2f33-4f79-533f9b7c9ffd@well-typed.com>

> This <https://hackage.haskell.org/package/vec-0.4/docs/Data-Vec-DataFamily-SpineStrict-Pigeonhole.html> in Hackage is something a rank amateur like me can't fathom. ... Anyone know how I can figure this mystery out, like at least find the author or someone that knows something about this?

Regarding this part of the question, if you click the "Contents" link at
the top of the page to which you linked, it will take you to the package
main page (https://hackage.haskell.org/package/vec-0.4). The column on
the right gives the author's name and email address, and a link to the
source repository (https://github.com/phadej/vec).

The main column on that page gives the package description, which may
help explain and motivate what is going on a bit more. In this case it
also links to some relevant papers.

Hope this helps,

Adam


On 29/11/2021 04:59, David Feuer wrote:
> No, this seems to have nothing to do with the pigeonhole principle. It
> seems to be about the sizes of length-indexed vectors. The "pigeonhole
> size" is just the vector length, available at the type level. This all
> seems to be about matching up vectors to representable functors. So it
> would match up
> 
>     data Foo a = Foo a a a a
> 
> to the type of vectors of length 4, giving functions to convert between
> them. I'm ... not exactly sure what purpose this serves.
> 
> On Sun, Nov 28, 2021, 11:07 PM Galaxy Being <borgauf at gmail.com
> <mailto:borgauf at gmail.com>> wrote:
> 
>     Spam detection software, running on the system "mail.haskell.org
>     <http://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-SpineStrict-Pigeonhole.html
>     <https://hackage.haskell.org/package/vec-0.4/docs/Data-Vec-DataFamily-SpineStrict-Pigeonhole.html>>
>        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 <http://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.
> 
> 
> 
> 
>     ---------- Forwarded message ----------
>     From: Galaxy Being <borgauf at gmail.com <mailto:borgauf at gmail.com>>
>     To: haskell-cafe <haskell-cafe at haskell.org
>     <mailto:haskell-cafe at haskell.org>>
>     Cc: 
>     Bcc: 
>     Date: Sun, 28 Nov 2021 22:05:44 -0600
>     Subject: What is Data.Vec.DataFamily.SpineStrict.Pigeonhole and why
>     is it following me?
>     This
>     <https://hackage.haskell.org/package/vec-0.4/docs/Data-Vec-DataFamily-SpineStrict-Pigeonhole.html>
>     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?
> 
>     -- 
>     ⨽
>     Lawrence Bottorff
>     Grand Marais, MN, USA
>     borgauf at gmail.com <mailto:borgauf at gmail.com>



-- 
Adam Gundry, Haskell Consultant
Well-Typed LLP, https://www.well-typed.com/

Registered in England & Wales, OC335890
118 Wymering Mansions, Wymering Road, London W9 2NF, England

From simon at joyful.com  Thu Dec  2 08:18:03 2021
From: simon at joyful.com (Simon Michael)
Date: Wed, 1 Dec 2021 22:18:03 -1000
Subject: [Haskell-cafe] ANN: hledger 1.24
Message-ID: <FBFB0E57-1F51-4835-B2E1-BFAB782FC70C@joyful.com>

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-install/hledger-install.sh
$ 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


From Graham.Hutton at nottingham.ac.uk  Thu Dec  2 08:47:12 2021
From: Graham.Hutton at nottingham.ac.uk (Graham Hutton)
Date: Thu, 2 Dec 2021 08:47:12 +0000
Subject: [Haskell-cafe] 10 PhD studentships in Nottingham
Message-ID: <1E5CC6E0-9CD8-451D-AA81-C6401EED18C1@nottingham.ac.uk>

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.





From ida.bzowska at gmail.com  Thu Dec  2 13:07:26 2021
From: ida.bzowska at gmail.com (Ida Bzowska)
Date: Thu, 2 Dec 2021 14:07:26 +0100
Subject: [Haskell-cafe] Call for Haskell.org Committee Nominations
Message-ID: <CAOOeZjBAEQ8Tf8ad3Nb7X7_ivuV9b66-WNhaW=x5A2eAowUVBg@mail.gmail.com>

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/3758
and drop us a line.
λCheers
Ida Bzowska
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211202/2b9c8ac6/attachment.html>

From csaba.hruska at gmail.com  Thu Dec  2 15:29:34 2021
From: csaba.hruska at gmail.com (Csaba Hruska)
Date: Thu, 2 Dec 2021 16:29:34 +0100
Subject: [Haskell-cafe] Why and How the External STG Interpreter is Useful
 (Online presentation, Dec 2, Thursday, 17:00 UTC)
Message-ID: <CANjChEorPN-Xd2rtSbM-Db-29CRPA_cuHWt0PUD0rx=7Bk8KxA@mail.gmail.com>

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211202/a07dc302/attachment.html>

From elenam at morris.umn.edu  Fri Dec  3 01:11:23 2021
From: elenam at morris.umn.edu (Elena Machkasova)
Date: Thu, 2 Dec 2021 19:11:23 -0600
Subject: [Haskell-cafe] Trends in Functional Programming in Education 2022
	2nd call for submissions
Message-ID: <CABVKp4dnCfgVoG3pLTAQuA3t4S0DkAZd7DTpducjhaW4wMXBhg@mail.gmail.com>

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211202/162bc23e/attachment.html>

From ben.franksen at online.de  Fri Dec  3 08:30:53 2021
From: ben.franksen at online.de (Ben Franksen)
Date: Fri, 3 Dec 2021 09:30:53 +0100
Subject: [Haskell-cafe] Breaking change to Eq accepted by Core Libraries
	Committee
In-Reply-To: <CAKFCL4W--z2X+oknEZhGrbbY+M7Xht1Ab4Wj7P9x8b4+m+O78g@mail.gmail.com>
References: <e3bc44899cff2fb014078976e9d70982173bbf4e.camel@aatal-apotheke.de>
 <CANBN=mtqDA_Ny0m0XTuiQmnMch_AhXki3a_vZa6o56-UGVE6mQ@mail.gmail.com>
 <YFabqdYGutZrARlaOZQBjJjO59SBWZYbeCf3twZtWFCV4-p0xMnlEpuCSQzRpE_zS6pqjN4GaELSlq2T-Nig4mqkugHUNzVLXf6DVknRP34=@pm.me>
 <CANBN=mszLV=ub3LAN1S9TcriWWLXf+nFs8yDxRrD_-kHdaja4A@mail.gmail.com>
 <CAKFCL4W--z2X+oknEZhGrbbY+M7Xht1Ab4Wj7P9x8b4+m+O78g@mail.gmail.com>
Message-ID: <sockjt$9a6$1@ciao.gmane.io>

Am 14.11.21 um 20:46 schrieb Brandon Allbery:
> I didn't understand that either. The original discussion seemed to
> have concluded that there was no point to the change aside from
> breaking some programs, then suddenly it was proposed and accepted.
> I'm confused….

Same here.

Ben
-- 
I would rather have questions that cannot be answered, than answers that
cannot be questioned.  -- Richard Feynman



From csaba.hruska at gmail.com  Fri Dec  3 09:30:47 2021
From: csaba.hruska at gmail.com (Csaba Hruska)
Date: Fri, 3 Dec 2021 10:30:47 +0100
Subject: [Haskell-cafe] Why and How the External STG Interpreter is
 Useful (Online presentation, Dec 2, Thursday, 17:00 UTC)
In-Reply-To: <CANjChEorPN-Xd2rtSbM-Db-29CRPA_cuHWt0PUD0rx=7Bk8KxA@mail.gmail.com>
References: <CANjChEorPN-Xd2rtSbM-Db-29CRPA_cuHWt0PUD0rx=7Bk8KxA@mail.gmail.com>
Message-ID: <CANjChEqGqyWLSjpNa-dXDBh0GuwBmV+D=-ad+enCTePLsStcnw@mail.gmail.com>

Hello,
The presentation recording <https://www.youtube.com/watch?v=wt6iCgYmVGA>
and slides
<https://docs.google.com/presentation/d/1Lmfpwtx_7TbIAGYnSE0HqkawRu75y2GGwbObuu0xYPY/edit?usp=sharing>
are available now.

Regards,
Csaba

On Thu, Dec 2, 2021 at 4:29 PM Csaba Hruska <csaba.hruska at gmail.com> wrote:

> 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211203/9d627c56/attachment.html>

From ivanperezdominguez at gmail.com  Fri Dec  3 14:26:38 2021
From: ivanperezdominguez at gmail.com (Ivan Perez)
Date: Fri, 3 Dec 2021 09:26:38 -0500
Subject: [Haskell-cafe] ANN: NASA's ogma
Message-ID: <CACZKWEJSUPb2tRKDBWBDrJOn3EfxkikCn3B92i-Vxy2pd=OoHg@mail.gmail.com>

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211203/436d7898/attachment.html>

From johannes.waldmann at htwk-leipzig.de  Fri Dec  3 16:11:57 2021
From: johannes.waldmann at htwk-leipzig.de (Johannes Waldmann)
Date: Fri, 3 Dec 2021 17:11:57 +0100
Subject: [Haskell-cafe] Output order of Data.List.permutations?
Message-ID: <6db78dca-188d-bc41-d005-9bd7d713ce8e@htwk-leipzig.de>

Dear Cafe -

what is the ordering of the output of
https://hackage.haskell.org/package/base-4.16.0.0/docs/src/Data.OldList.html#permutations
-
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-10-1.html
 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.

From johannes.waldmann at htwk-leipzig.de  Sat Dec  4 19:52:50 2021
From: johannes.waldmann at htwk-leipzig.de (Johannes Waldmann)
Date: Sat, 4 Dec 2021 20:52:50 +0100
Subject: [Haskell-cafe] Output order of Data.List.permutations?
In-Reply-To: <6db78dca-188d-bc41-d005-9bd7d713ce8e@htwk-leipzig.de>
References: <6db78dca-188d-bc41-d005-9bd7d713ce8e@htwk-leipzig.de>
Message-ID: <8ba1f9ac-1398-5138-7022-909a1f224f35@htwk-leipzig.de>

> what is the ordering of the output of
> https://hackage.haskell.org/package/base-4.16.0.0/docs/src/Data.OldList.html#permutations
> -
> and why is it not lexicographic? 


OK I think I know what's happening.


1. This function works on infinite lists:
it will permute finite prefixes, in increasing length,
while keeping the infinite suffix.

map (take 5) $ take 3 $ permutations [1 .. ] -- infinite!

[[1,2,3,4,5],[2,1,3,4,5],[3,2,1,4,5]]

This specification is incompatible with lexicographic order.
We could aim for inverse-lexicographic decrease
(i.e., `reverse $ map reverse $ permutations xs` is increasing)
but currently, it's not.


2. The program is equivalent (try it!) to

permutations xs0 =  xs0 : do
  (is', t:ts) <- splits xs0
  xs <- permutations $ reverse is'   -- reverse not needed, see below
  (pre, p:ost) <- splits xs
  return $ pre <> (t : p : ost <> ts)

with this auxiliary function
(that I sometimes wish was in Data.List)

splits xs = zip (inits xs) (tails xs)
splits "bar" = [("","bar"),("b","ar"),("ba","r"),("bar","")]

That is the form of the program that I have a chance to understand,
and prove correct. But -


3. This program contains several "append" (<>). Some are visible,
some are hidden in the  do  notation (?), and in Data.List.inits.
A series of uglification steps now transforms each "append"
into a function with an extra accumulating parameter,
and fuses some of these function calls.

E.g., "interleave" (from the source code)
is actually this function

interleave t ts xs r =
 ( map (<> ts) $ do
     (pre, p:ost) <- splits xs
     return $ pre <> [t] <> p:ost
 ) <> r

Accumulation will reverse lists.
Where reversal is not allowed, a parameter  xs :: [a]
is replaced by the function   (xs <>) :: [a] -> [a] .
In one place, reversal is kept (because it is irrelevant),
and that's why it appears in the above -
and contributes to the exotic order of output.


Truly a work of art. - I still wonder

* can we document this (perhaps find the original documentation)?
* was this necessary (or can the compiler do these transformations)?


- J.

From fumiexcel at gmail.com  Sun Dec  5 02:25:13 2021
From: fumiexcel at gmail.com (Fumiaki Kinoshita)
Date: Sun, 5 Dec 2021 11:25:13 +0900
Subject: [Haskell-cafe] Package takeover request for oath
Message-ID: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>

At the moment, oath is registered as a "reserved package name" (see
https://mail.haskell.org/pipermail/libraries/2021-December/031524.html) and
does not exist as an actual package.

I'd like to upload a package with this name unless there's a specific
reason why I should not.
My Hackage username is FumiakiKinoshita.

Best regards,
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211205/f3112897/attachment.html>

From johannes.waldmann at htwk-leipzig.de  Sun Dec  5 13:47:40 2021
From: johannes.waldmann at htwk-leipzig.de (Johannes Waldmann)
Date: Sun, 5 Dec 2021 14:47:40 +0100
Subject: [Haskell-cafe] Output order of Data.List.permutations?
In-Reply-To: <8ba1f9ac-1398-5138-7022-909a1f224f35@htwk-leipzig.de>
References: <6db78dca-188d-bc41-d005-9bd7d713ce8e@htwk-leipzig.de>
 <8ba1f9ac-1398-5138-7022-909a1f224f35@htwk-leipzig.de>
Message-ID: <4e0e8342-9f9e-e0f4-b5f0-5b228783a9c8@htwk-leipzig.de>

(sorry, I will be quiet after this) For historical references, see
https://www.imn.htwk-leipzig.de/~waldmann/etc/data-list-permutations/
The code appeared in the Haskell 1.3 Library report (1996)
and was modified in 2007. - J.

From metabind at protonmail.ch  Sun Dec  5 14:02:09 2021
From: metabind at protonmail.ch (Adrian)
Date: Sun, 05 Dec 2021 14:02:09 +0000
Subject: [Haskell-cafe] Endo a, endomorphisms
Message-ID: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211205/f52596a3/attachment.html>

From tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk  Sun Dec  5 14:13:37 2021
From: tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk (Tom Ellis)
Date: Sun, 5 Dec 2021 14:13:37 +0000
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
Message-ID: <20211205141336.GD20626@cloudinit-builder>

On Sun, Dec 05, 2021 at 02:02:09PM +0000, Adrian via Haskell-Cafe wrote:
> 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.

I'm not sure what you mean.  The morphisms in this case are exactly
functions.  "Endomorphism" and "endofunction" have the same meaning in
this context.

Tom

From metabind at protonmail.ch  Sun Dec  5 14:39:01 2021
From: metabind at protonmail.ch (Adrian)
Date: Sun, 05 Dec 2021 14:39:01 +0000
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <20211205141336.GD20626@cloudinit-builder>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
 <20211205141336.GD20626@cloudinit-builder>
Message-ID: <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>


‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐

On Sunday, December 5th, 2021 at 8:13 AM, Tom Ellis <tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk> wrote:

> On Sun, Dec 05, 2021 at 02:02:09PM +0000, Adrian via Haskell-Cafe wrote:
>
> > 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.
>
> I'm not sure what you mean. The morphisms in this case are exactly
>
> functions. "Endomorphism" and "endofunction" have the same meaning in
>
> this context.
>
> Tom
>

According to Algebra [Hungerford 74], an endomorphism is an endofunction that is a homomorphism.
A set of endomorphisms is quite distinct from a set of endofunctions in this regard.


From tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk  Sun Dec  5 14:48:59 2021
From: tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk (Tom Ellis)
Date: Sun, 5 Dec 2021 14:48:59 +0000
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
 <20211205141336.GD20626@cloudinit-builder>
 <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
Message-ID: <20211205144859.GE20626@cloudinit-builder>

On Sun, Dec 05, 2021 at 02:39:01PM +0000, Adrian wrote:
> On Sunday, December 5th, 2021 at 8:13 AM, Tom Ellis <tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk> wrote:
> > On Sun, Dec 05, 2021 at 02:02:09PM +0000, Adrian via Haskell-Cafe wrote:
> > > 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.
> >
> > I'm not sure what you mean. The morphisms in this case are exactly
> > functions. "Endomorphism" and "endofunction" have the same meaning in
> > this context.
> 
> According to Algebra [Hungerford 74], an endomorphism is an
> endofunction that is a homomorphism.  A set of endomorphisms is
> quite distinct from a set of endofunctions in this regard.

The "endomorphism" terminology in use in this case comes from category
theory rather than algebra narrowly:

> An endomorphism of an object x in a category C is a morphism f: x → x

https://ncatlab.org/nlab/show/endomorphism

In the case of the Endo documentation, the category under
consideration is Hask, the category whose objects are Haskell types
and whose morphisms are Haskell functions.  Therefore "endofunction"
and "endomorphism" refer to the same thing in this context.

From tonyzorman at mailbox.org  Sun Dec  5 14:56:51 2021
From: tonyzorman at mailbox.org (Tony Zorman)
Date: Sun, 05 Dec 2021 15:56:51 +0100
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
 <20211205141336.GD20626@cloudinit-builder>
 <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
Message-ID: <871r2rkslo.fsf@hyperspace>

On Sun, Dec 05 2021 14:39, Adrian via Haskell-Cafe wrote:
> According to Algebra [Hungerford 74], an endomorphism is an
> endofunction that is a homomorphism.  A set of endomorphisms is quite
> distinct from a set of endofunctions in this regard.

What counts as a "homomorphism" is very dependent on the context that
you're in.  Here, we are not studying some exotic algebraic structure,
but really just functions over a set.  In particular, "(homo)morphism"
becomes an alias for "function".

From metabind at protonmail.ch  Sun Dec  5 15:24:13 2021
From: metabind at protonmail.ch (Adrian)
Date: Sun, 05 Dec 2021 15:24:13 +0000
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <871r2rkslo.fsf@hyperspace>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
 <20211205141336.GD20626@cloudinit-builder>
 <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
 <871r2rkslo.fsf@hyperspace>
Message-ID: <oqIzROIFCznjXWXMldOS6Q948rxOSvDzD7nFZ4DQsx94nFsRIDhVfIw3nERGpHicLPla5TWOnh_pw8ErTQI2d4fcdabS3M4zfAeL8zrA4r8=@protonmail.ch>

‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐

On Sunday, December 5th, 2021 at 8:53 AM, Tony Zorman <tonyzorman at mailbox.org> wrote:

> On Sun, Dec 05 2021 14:39, Adrian via Haskell-Cafe wrote:
>
> > According to Algebra [Hungerford 74], an endomorphism is an
> >
> > endofunction that is a homomorphism. A set of endomorphisms is quite
> >
> > distinct from a set of endofunctions in this regard.
>
> What counts as a "homomorphism" is very dependent on the context that
>
> you're in. Here, we are not studying some exotic algebraic structure,
>
> but really just functions over a set. In particular, "(homo)morphism"
>
> becomes an alias for "function".

I note that in the paper "Monoid: Theme and Variations" [Yorgey 2012], a monoid homomorphism
is defined in a manner consistent with the definitions found in Algebra [Hungerford 74]:

A monoid homomorphism is a function from one monoidal type
to another which preserves monoid structure; that is, a function f
satisfying the laws:

f ε = ε
f (x <> y) = f x <> f y

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.


From tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk  Sun Dec  5 15:46:01 2021
From: tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk (Tom Ellis)
Date: Sun, 5 Dec 2021 15:46:01 +0000
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <oqIzROIFCznjXWXMldOS6Q948rxOSvDzD7nFZ4DQsx94nFsRIDhVfIw3nERGpHicLPla5TWOnh_pw8ErTQI2d4fcdabS3M4zfAeL8zrA4r8=@protonmail.ch>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
 <20211205141336.GD20626@cloudinit-builder>
 <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
 <871r2rkslo.fsf@hyperspace>
 <oqIzROIFCznjXWXMldOS6Q948rxOSvDzD7nFZ4DQsx94nFsRIDhVfIw3nERGpHicLPla5TWOnh_pw8ErTQI2d4fcdabS3M4zfAeL8zrA4r8=@protonmail.ch>
Message-ID: <20211205154601.GF20626@cloudinit-builder>

On Sun, Dec 05, 2021 at 03:24:13PM +0000, Adrian via Haskell-Cafe wrote:
> ‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐
> 
> On Sunday, December 5th, 2021 at 8:53 AM, Tony Zorman <tonyzorman at mailbox.org> wrote:
> 
> > On Sun, Dec 05 2021 14:39, Adrian via Haskell-Cafe wrote:
> >
> > > According to Algebra [Hungerford 74], an endomorphism is an
> > >
> > > endofunction that is a homomorphism. A set of endomorphisms is quite
> > >
> > > distinct from a set of endofunctions in this regard.
> >
> > What counts as a "homomorphism" is very dependent on the context that
> >
> > you're in. Here, we are not studying some exotic algebraic structure,
> >
> > but really just functions over a set. In particular, "(homo)morphism"
> >
> > becomes an alias for "function".
> 
> I note that in the paper "Monoid: Theme and Variations" [Yorgey 2012], a monoid homomorphism
> is defined in a manner consistent with the definitions found in Algebra [Hungerford 74]:
> 
> A monoid homomorphism is a function from one monoidal type to
> another which preserves monoid structure; that is, a function f
> satisfying the laws:
> 
> f ε = ε
> f (x <> y) = f x <> f y
> 
> 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.

Yes, I agree that would be a clarifying rewrite, avoiding a clash of
terminology.

From tonyzorman at mailbox.org  Sun Dec  5 15:56:59 2021
From: tonyzorman at mailbox.org (Tony Zorman)
Date: Sun, 05 Dec 2021 16:56:59 +0100
Subject: [Haskell-cafe] Endo a, endomorphisms
In-Reply-To: <oqIzROIFCznjXWXMldOS6Q948rxOSvDzD7nFZ4DQsx94nFsRIDhVfIw3nERGpHicLPla5TWOnh_pw8ErTQI2d4fcdabS3M4zfAeL8zrA4r8=@protonmail.ch>
References: <teNrw8To1t-ZN6vWzaShmrrtpidntMF61ghEVGPcUgHRp_yuR84wzo5TrMFdkD9nsYiSBpIg1DZY9jdpxW6_887Mv-ec0aF-XDYlT2_BCX0=@protonmail.ch>
 <20211205141336.GD20626@cloudinit-builder>
 <ZINbSWdj6oyqP7DjpM5zW6G61WwWiTnqV0n0ijq6il4orA0aEsQ1AgZSSFebBIYX1atob1t_1wc5OyTj6Kmhk096-7wTQ6IG6fX5n5ooO08=@protonmail.ch>
 <871r2rkslo.fsf@hyperspace>
 <oqIzROIFCznjXWXMldOS6Q948rxOSvDzD7nFZ4DQsx94nFsRIDhVfIw3nERGpHicLPla5TWOnh_pw8ErTQI2d4fcdabS3M4zfAeL8zrA4r8=@protonmail.ch>
Message-ID: <87v903jb90.fsf@hyperspace>

On Sun, Dec 05 2021 15:24, Adrian wrote:
> I note that in the paper "Monoid: Theme and Variations" [Yorgey 2012],
> a monoid homomorphism is defined in a manner consistent with the
> definitions found in Algebra [Hungerford 74]:

That is definitely true, but we are not talking about monoid
endomorphisms, we are talking about endomorphisms _over a set_ that
happen to form a monoid.  Endomorphisms over a monoid M certainly need
to be compatible with the monoid structure on M, but this is orthogonal
to the present question.

When `Endo` talks about endomorphisms, it means endomorphisms over the
type (think: the set) `a`.  More specifically, for any set X we can talk
about all functions f: X → X.  These are called "endomorphisms" even
though they are only functions, because that's exactly what a
homomorphism of a set is.

The point of `Endo` being in Data.Monoid is that function composition of
endomorphisms forms a monoid (with the identity element being the
identity morphism) regardless of the underlying structure—be that a set,
a monoid, a group, ...

From fumiexcel at gmail.com  Mon Dec  6 07:00:44 2021
From: fumiexcel at gmail.com (Fumiaki Kinoshita)
Date: Mon, 6 Dec 2021 16:00:44 +0900
Subject: [Haskell-cafe] Package takeover request for oath
In-Reply-To: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
References: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
Message-ID: <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>

CC'd Gershom as the system failed to deliver this mail via hackage-admin.

Has anyone heard from hvr? I haven't seen him in a while, either on GitHub
or ML

2021年12月5日(日) 11:25 Fumiaki Kinoshita <fumiexcel at gmail.com>:

> At the moment, oath is registered as a "reserved package name" (see
> https://mail.haskell.org/pipermail/libraries/2021-December/031524.html)
> and does not exist as an actual package.
>
> I'd like to upload a package with this name unless there's a specific
> reason why I should not.
> My Hackage username is FumiakiKinoshita.
>
> Best regards,
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211206/e43354e5/attachment.html>

From hecate at glitchbra.in  Mon Dec  6 08:16:09 2021
From: hecate at glitchbra.in (=?UTF-8?Q?H=c3=a9cate?=)
Date: Mon, 6 Dec 2021 09:16:09 +0100
Subject: [Haskell-cafe] Package takeover request for oath
In-Reply-To: <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>
References: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
 <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>
Message-ID: <a16caa84-228f-3b25-d304-43f3107eaac0@glitchbra.in>

Hi Fumiaki,

hvr seems to have disengaged from his responsibilities around last year 
or so.

Le 06/12/2021 à 08:00, Fumiaki Kinoshita a écrit :
> CC'd Gershom as the system failed to deliver this mail via hackage-admin.
>
> Has anyone heard from hvr? I haven't seen him in a while, either on 
> GitHub or ML
>
> 2021年12月5日(日) 11:25 Fumiaki Kinoshita <fumiexcel at gmail.com>:
>
>     At the moment, oath is registered as a "reserved package name"
>     (see
>     https://mail.haskell.org/pipermail/libraries/2021-December/031524.html)
>     and does not exist as an actual package.
>
>     I'd like to upload a package with this name unless there's a
>     specific reason why I should not.
>     My Hackage username is FumiakiKinoshita.
>
>     Best regards,
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.

-- 
Hécate ✨
🐦: @TechnoEmpress
IRC: Hecate
WWW:https://glitchbra.in
RUN: BSD
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211206/69f9328d/attachment.html>

From olf at aatal-apotheke.de  Mon Dec  6 22:45:26 2021
From: olf at aatal-apotheke.de (Olaf Klinke)
Date: Mon, 06 Dec 2021 23:45:26 +0100
Subject: [Haskell-cafe] Endo a, endomorphisms
Message-ID: <959aa1ec7db5be56aef0bdfc32f116e1222ba1d8.camel@aatal-apotheke.de>

> 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 (<>).


From johannes.waldmann at htwk-leipzig.de  Tue Dec  7 12:16:19 2021
From: johannes.waldmann at htwk-leipzig.de (Johannes Waldmann)
Date: Tue, 7 Dec 2021 13:16:19 +0100
Subject: [Haskell-cafe] with -XOverloadedStrings,
	when is the implied fromString floated out?
Message-ID: <41468aae-14b3-39d0-6a56-19c5d3b30b01@htwk-leipzig.de>

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.


From kai.prott at hotmail.de  Tue Dec  7 13:16:57 2021
From: kai.prott at hotmail.de (Kai-Oliver Prott)
Date: Tue, 7 Dec 2021 14:16:57 +0100
Subject: [Haskell-cafe] with -XOverloadedStrings,
 when is the implied fromString floated out?
In-Reply-To: <41468aae-14b3-39d0-6a56-19c5d3b30b01@htwk-leipzig.de>
References: <41468aae-14b3-39d0-6a56-19c5d3b30b01@htwk-leipzig.de>
Message-ID: <AM0PR09MB39241E3E8D275F7D75AF9A028F6E9@AM0PR09MB3924.eurprd09.prod.outlook.com>

Hey

By default, GHCi uses bytecode, which interacts badly with some 
optimizations according to the GHC manual.
However, you can force GHCi to use object-code via `-fobject-code`. 
There are some small disadvantages, but at least it works.

{-# language OverloadedStrings #-}
{-# OPTIONS_GHC -fobject-code -O1 #-}
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]

ghci> main
[**fromString**
Foo,Foo]

- Kai

On 07.12.21 13:16, Johannes Waldmann wrote:
> 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.
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.

From fumiexcel at gmail.com  Wed Dec  8 01:45:19 2021
From: fumiexcel at gmail.com (Fumiaki Kinoshita)
Date: Wed, 8 Dec 2021 10:45:19 +0900
Subject: [Haskell-cafe] Package takeover request for oath
In-Reply-To: <a16caa84-228f-3b25-d304-43f3107eaac0@glitchbra.in>
References: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
 <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>
 <a16caa84-228f-3b25-d304-43f3107eaac0@glitchbra.in>
Message-ID: <CAATCwU=MGkR4XEHB+Jy2K7X+QCCkv81-XV=qcFN0m8C0USecUQ@mail.gmail.com>

OK. Hackage admin, could you either remove the release candidate for oath,
or add me to the list of maintainers?

2021年12月6日(月) 17:19 Hécate <hecate at glitchbra.in>:

> Hi Fumiaki,
>
> hvr seems to have disengaged from his responsibilities around last year or
> so.
> Le 06/12/2021 à 08:00, Fumiaki Kinoshita a écrit :
>
> CC'd Gershom as the system failed to deliver this mail via hackage-admin.
>
> Has anyone heard from hvr? I haven't seen him in a while, either on GitHub
> or ML
>
> 2021年12月5日(日) 11:25 Fumiaki Kinoshita <fumiexcel at gmail.com>:
>
>> At the moment, oath is registered as a "reserved package name" (see
>> https://mail.haskell.org/pipermail/libraries/2021-December/031524.html)
>> and does not exist as an actual package.
>>
>> I'd like to upload a package with this name unless there's a specific
>> reason why I should not.
>> My Hackage username is FumiakiKinoshita.
>>
>> Best regards,
>>
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
>
> --
> Hécate ✨
> 🐦: @TechnoEmpress
> IRC: Hecate
> WWW: https://glitchbra.in
> RUN: BSD
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211208/9fea19a5/attachment.html>

From borgauf at gmail.com  Wed Dec  8 02:10:35 2021
From: borgauf at gmail.com (Galaxy Being)
Date: Tue, 7 Dec 2021 20:10:35 -0600
Subject: [Haskell-cafe] Is the Haskell list comprehension just a Cartesian
	product machine?
Message-ID: <CAFAhFSXi3Z1WN5aJT1FgSex+HcZXN+c4iLBTG=-J+mOAm6_dyw@mail.gmail.com>

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 at gmail.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211207/c8adb523/attachment.html>

From trebla at vex.net  Wed Dec  8 02:46:48 2021
From: trebla at vex.net (Albert Y. C. Lai)
Date: Tue, 7 Dec 2021 21:46:48 -0500
Subject: [Haskell-cafe] Is the Haskell list comprehension just a
 Cartesian product machine?
In-Reply-To: <CAFAhFSXi3Z1WN5aJT1FgSex+HcZXN+c4iLBTG=-J+mOAm6_dyw@mail.gmail.com>
References: <CAFAhFSXi3Z1WN5aJT1FgSex+HcZXN+c4iLBTG=-J+mOAm6_dyw@mail.gmail.com>
Message-ID: <bb362da7-78c5-9137-b6a1-1e20ebae629a@vex.net>

On 2021-12-07 9:10 p.m., Galaxy Being wrote:
> 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.

Short answer is yes.

Level 1:

[ (x,y) | x <- [1,2], y <- [3,4,5] ]

is a cartesian product. This corroborates with that <*> for list does 
cartesian product, i.e.,

pure (,) <*> [1,2] <*> [3,4,5]

And replacing (x,y) by arbitrary f x y does not really change the story.


Level 2:

[ (x,y) | x <- [1,2], y <- [x .. x+x] ]

Do you call that a cartesian product?

I would call it a dependent cartesian product.

{1,2} x (this set depends on the 1 or 2)

On the bright side, I think high-schoolers are flexible enough to accept 
this as a kind of cartesian product, too.

This corroborates with that >>= for list does dependent cartesian 
product, i.e.,

[1,2] >>= \x -> [x .. x+x] >>= \y -> pure (x,y)

Again, replacing (x,y) by arbitrary f x y does not really change the story.


Level 3:

Will you also tell your students about this?

[ (x,y) | x <- [1,2], x > 1, y <- [x .. x+x], y < 3 ]

Some kind of wacky cartesian product that's both dependent and conditional.

This needs empty from Alternative or mzero from MonadPlus:

Define (already in Control.Monad):

guard c = if c then pure () else empty

[1,2]         >>= \x ->
guard (x > 1) >>
[x .. x+x]    >>= \y ->
guard (y < 3) >>
pure (x,y)

{1,2} x (this set depends on the 1 or 2, can be empty) x ...


Have fun.

From ietf-dane at dukhovni.org  Wed Dec  8 03:37:47 2021
From: ietf-dane at dukhovni.org (Viktor Dukhovni)
Date: Tue, 7 Dec 2021 22:37:47 -0500
Subject: [Haskell-cafe] Is the Haskell list comprehension just a
 Cartesian product machine?
In-Reply-To: <bb362da7-78c5-9137-b6a1-1e20ebae629a@vex.net>
References: <CAFAhFSXi3Z1WN5aJT1FgSex+HcZXN+c4iLBTG=-J+mOAm6_dyw@mail.gmail.com>
 <bb362da7-78c5-9137-b6a1-1e20ebae629a@vex.net>
Message-ID: <YbAoi/mpwwIo+JB8@straasha.imrryr.org>

On Tue, Dec 07, 2021 at 09:46:48PM -0500, Albert Y. C. Lai wrote:

> Level 1:
> ...
> Level 2:
> ...
> Level 3:
> ...

And we haven't even touched either of:

    {-# LANGUAGE ParallelListComp #-}
    {-# LANGUAGE TransformListComp #-}

or the fact that in the dependent case, we might not output anything
that feels like a product:

    concat :: [[a]] -> [a]
    concat xss = [ x | xs <- xss, x <- xs ]

So indeed list comprehensions are products in the simplest cases, and do
generate nested loops under various conditions, but they're considerly
more flexible.

-- 
    Viktor.

From ky3 at atamo.com  Wed Dec  8 04:12:11 2021
From: ky3 at atamo.com (Kim-Ee Yeoh)
Date: Wed, 8 Dec 2021 11:12:11 +0700
Subject: [Haskell-cafe] Missing messages in the ML
In-Reply-To: <CAM8RHpHChMD_auQ6UZzMdzR+-zWov9dyGF+uN5Gny+RtBqq6+w@mail.gmail.com>
References: <CAE1pOi1gd6XYPo6WQPk7=qnV0dqxqoBiSVty_NdTMhc=dFtDSQ@mail.gmail.com>
 <20211121181816.GA20276@cloudinit-builder>
 <24930af1-7f3e-e162-f6d9-965468101bc0@durchholz.org>
 <CC86A6DC-CBD7-4CE0-BDE7-27FE5DF5965F@gmail.com>
 <CAH9BU=zSNSgJKSSofbtw4dCzUVpkg7UBjtFYm57V6ZwYV3DbjQ@mail.gmail.com>
 <CAPY+ZdR3qRcM4wBtu_r4HFEgzq82N6JM8qSz0rFRNu=TH7YLzw@mail.gmail.com>
 <Ojb60d4gH_G4ptYZPTEeUAfUqFSRjkc2RPLgwJ3mSumYwaCJgr5TRNhq0MYO6LE6hdREEAYCj3SKiCkH-415M4DofSR4mcy1pw4RMCPvSqw=@tomsmeding.com>
 <YZtQhrPc83PyVfL1@straasha.imrryr.org>
 <CAM8RHpHChMD_auQ6UZzMdzR+-zWov9dyGF+uN5Gny+RtBqq6+w@mail.gmail.com>
Message-ID: <CAPY+ZdQtmcGSTbmzhfXEpp+Db1T1PaaGTnitn82qUs+_Vc076Q@mail.gmail.com>

Mailman still isn’t reflecting all mail. Just recently, this arrived in my
email:

https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134940.html

But not the earlier two posts in the same thread:

https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134938.html
https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134939.html

What has changed in the email infrastructure recently?

On Mon, Nov 22, 2021 at 10:18 PM Gershom B <gershomb at gmail.com> wrote:

> Thanks! We're looking into this with our host.
>
> -g
>
> On Mon, Nov 22, 2021 at 3:34 AM Viktor Dukhovni <ietf-dane at dukhovni.org>
> wrote:
> >
> > On Mon, Nov 22, 2021 at 07:33:43AM +0000, Tom Smeding wrote:
> >
> > > I got at least one message from Tom Ellis in the Logging conversation,
> > > one from Joachim Durchholz, and some more. I'm definitely not included
> > > in the conversation personnally.
> > >
> > > I have no idea what might be going wrong, but I think it's not
> > > forgetting to reply to all.
> >
> > [ TL;DR haskell.org DNS is misconfigured ]
> >
> > I guess I can put my SMTP/DNS guru hat on and explain what is happening.
> > Here's some (cryptic) data from my logs:
> >
> >     Nov 22 01:42:13 straasha postfix/smtpd[52426]:
> >         disconnect from unknown[145.40.99.54]
> >         ehlo=2 starttls=1 mail=1
> > -->     rcpt=0/1 data=0/1 rset=1 quit=1 commands=6/8
> >
> >     Nov 22 02:19:13 straasha postfix/smtpd[52686]:
> >         disconnect from unknown[2604:1380:4641:a100::5]
> >         ehlo=2 starttls=1 mail=1 rcpt=1 data=1 quit=1 commands=7
> >
> >     Nov 22 02:35:10 straasha postfix/smtpd[53049]:
> >         disconnect from unknown[2604:1380:4641:a100::5]
> >         ehlo=2 starttls=1 mail=1 rcpt=1 data=1 quit=1 commands=7
> >
> >     Nov 22 02:42:51 straasha postfix/smtpd[53100]:
> >         disconnect from unknown[145.40.99.54]
> >         ehlo=2 starttls=1 mail=1
> > -->     rcpt=0/1 data=0/1 rset=1 quit=1 commands=6/8
> >
> > The first and last message were rejected: "rcpt=0/1, data=0/1" mean that
> > "RCPT TO" and "DATA" commands were refused.  The middle two messages
> > were accepted.
> >
> > The reason is DNS misconfiguration of the of mta1.haskell.org:
> >
> >     $ set -- mta1.haskell.org misc-services-origin-migration.haskell.org
> >     $ brief() { dig +noall +ans +nocl +nottl "$@"; }
> >     $ echo; for fwd; do brief -t a $fwd; brief -t aaaa $fwd; done
> >
> >     mta1.haskell.org.   A       145.40.99.54
> >
> >     $ brief() { dig +noall +ans +nocl +nottl "$@"; }
> >     $ set -- 145.40.99.54 2604:1380:4641:a100::5
> >     $ echo; for rev; do brief -t ptr -x $rev; done
> >
> >
>  5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.a.1.4.6.4.0.8.3.1.4.0.6.2.ip6.arpa.
> PTR misc-services-origin-migration.haskell.org.
> >
> > Only the IPv6 address has a PTR record, and even then it does not
> > forward resolve.  SMTP clients with no PTR records are routinely refused
> > service.  My mail server tolerates lack of forward mappings, but the PTR
> > is required.
> >
> > The correct DNS configuration would be:
> >
> >     forward zone:
> >         mta1.haskell.org.   A       145.40.99.54
> >         mta1.haskell.org.   AAAA    2604:1380:4641:a100::5
> >
> >     reverse IPv6 zone
> >
>  5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.a.1.4.6.4.0.8.3.1.4.0.6.2.ip6.arpa.
> PTR mta1.haskell.org.
> >
> >     reverse IPv4 zone
> >         54.99.40.145.in-addr.arpa. PTR mta.haskell.org.
> >
> > --
> >     Viktor.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.

-- 
-- Kim-Ee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211208/3efa077b/attachment.html>

From gershomb at gmail.com  Wed Dec  8 04:43:12 2021
From: gershomb at gmail.com (Gershom B)
Date: Tue, 7 Dec 2021 23:43:12 -0500
Subject: [Haskell-cafe] Missing messages in the ML
In-Reply-To: <CAPY+ZdQtmcGSTbmzhfXEpp+Db1T1PaaGTnitn82qUs+_Vc076Q@mail.gmail.com>
References: <CAE1pOi1gd6XYPo6WQPk7=qnV0dqxqoBiSVty_NdTMhc=dFtDSQ@mail.gmail.com>
 <20211121181816.GA20276@cloudinit-builder>
 <24930af1-7f3e-e162-f6d9-965468101bc0@durchholz.org>
 <CC86A6DC-CBD7-4CE0-BDE7-27FE5DF5965F@gmail.com>
 <CAH9BU=zSNSgJKSSofbtw4dCzUVpkg7UBjtFYm57V6ZwYV3DbjQ@mail.gmail.com>
 <CAPY+ZdR3qRcM4wBtu_r4HFEgzq82N6JM8qSz0rFRNu=TH7YLzw@mail.gmail.com>
 <Ojb60d4gH_G4ptYZPTEeUAfUqFSRjkc2RPLgwJ3mSumYwaCJgr5TRNhq0MYO6LE6hdREEAYCj3SKiCkH-415M4DofSR4mcy1pw4RMCPvSqw=@tomsmeding.com>
 <YZtQhrPc83PyVfL1@straasha.imrryr.org>
 <CAM8RHpHChMD_auQ6UZzMdzR+-zWov9dyGF+uN5Gny+RtBqq6+w@mail.gmail.com>
 <CAPY+ZdQtmcGSTbmzhfXEpp+Db1T1PaaGTnitn82qUs+_Vc076Q@mail.gmail.com>
Message-ID: <CAM8RHpENNnBizbLQQ2V+fuDjBPCpHuzoTyy3BWuq_gdku=mejg@mail.gmail.com>

We migrated our secondary mail server, and have been working on
bringing its reputation back up. As Viktor diagnosed, it also had a
sending IP that did not have a PTR record, and that should now be
resolved, as of last week. But I realized just now that the ptr and
fwd lookup also have to correspond exactly, which they did not. That
should also be now fixed. Further, I've tried to turn off sending most
of our mailinglists through the secondary server, while the
configuration settles down further. Apologies for the delays --
getting a proper email host set up and acquiring proper reputation is
a rather expert task, and I'm far from an expert.

Cheers,
Gershom

On Tue, Dec 7, 2021 at 11:12 PM Kim-Ee Yeoh <ky3 at atamo.com> wrote:
>
> Mailman still isn’t reflecting all mail. Just recently, this arrived in my email:
>
> https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134940.html
>
> But not the earlier two posts in the same thread:
>
> https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134938.html
> https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134939.html
>
> What has changed in the email infrastructure recently?
>
> On Mon, Nov 22, 2021 at 10:18 PM Gershom B <gershomb at gmail.com> wrote:
>>
>> Thanks! We're looking into this with our host.
>>
>> -g
>>
>> On Mon, Nov 22, 2021 at 3:34 AM Viktor Dukhovni <ietf-dane at dukhovni.org> wrote:
>> >
>> > On Mon, Nov 22, 2021 at 07:33:43AM +0000, Tom Smeding wrote:
>> >
>> > > I got at least one message from Tom Ellis in the Logging conversation,
>> > > one from Joachim Durchholz, and some more. I'm definitely not included
>> > > in the conversation personnally.
>> > >
>> > > I have no idea what might be going wrong, but I think it's not
>> > > forgetting to reply to all.
>> >
>> > [ TL;DR haskell.org DNS is misconfigured ]
>> >
>> > I guess I can put my SMTP/DNS guru hat on and explain what is happening.
>> > Here's some (cryptic) data from my logs:
>> >
>> >     Nov 22 01:42:13 straasha postfix/smtpd[52426]:
>> >         disconnect from unknown[145.40.99.54]
>> >         ehlo=2 starttls=1 mail=1
>> > -->     rcpt=0/1 data=0/1 rset=1 quit=1 commands=6/8
>> >
>> >     Nov 22 02:19:13 straasha postfix/smtpd[52686]:
>> >         disconnect from unknown[2604:1380:4641:a100::5]
>> >         ehlo=2 starttls=1 mail=1 rcpt=1 data=1 quit=1 commands=7
>> >
>> >     Nov 22 02:35:10 straasha postfix/smtpd[53049]:
>> >         disconnect from unknown[2604:1380:4641:a100::5]
>> >         ehlo=2 starttls=1 mail=1 rcpt=1 data=1 quit=1 commands=7
>> >
>> >     Nov 22 02:42:51 straasha postfix/smtpd[53100]:
>> >         disconnect from unknown[145.40.99.54]
>> >         ehlo=2 starttls=1 mail=1
>> > -->     rcpt=0/1 data=0/1 rset=1 quit=1 commands=6/8
>> >
>> > The first and last message were rejected: "rcpt=0/1, data=0/1" mean that
>> > "RCPT TO" and "DATA" commands were refused.  The middle two messages
>> > were accepted.
>> >
>> > The reason is DNS misconfiguration of the of mta1.haskell.org:
>> >
>> >     $ set -- mta1.haskell.org misc-services-origin-migration.haskell.org
>> >     $ brief() { dig +noall +ans +nocl +nottl "$@"; }
>> >     $ echo; for fwd; do brief -t a $fwd; brief -t aaaa $fwd; done
>> >
>> >     mta1.haskell.org.   A       145.40.99.54
>> >
>> >     $ brief() { dig +noall +ans +nocl +nottl "$@"; }
>> >     $ set -- 145.40.99.54 2604:1380:4641:a100::5
>> >     $ echo; for rev; do brief -t ptr -x $rev; done
>> >
>> >     5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.a.1.4.6.4.0.8.3.1.4.0.6.2.ip6.arpa. PTR misc-services-origin-migration.haskell.org.
>> >
>> > Only the IPv6 address has a PTR record, and even then it does not
>> > forward resolve.  SMTP clients with no PTR records are routinely refused
>> > service.  My mail server tolerates lack of forward mappings, but the PTR
>> > is required.
>> >
>> > The correct DNS configuration would be:
>> >
>> >     forward zone:
>> >         mta1.haskell.org.   A       145.40.99.54
>> >         mta1.haskell.org.   AAAA    2604:1380:4641:a100::5
>> >
>> >     reverse IPv6 zone
>> >         5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.a.1.4.6.4.0.8.3.1.4.0.6.2.ip6.arpa. PTR mta1.haskell.org.
>> >
>> >     reverse IPv4 zone
>> >         54.99.40.145.in-addr.arpa. PTR mta.haskell.org.
>> >
>> > --
>> >     Viktor.
>> _______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>> Only members subscribed via the mailman list are allowed to post.
>
> --
> -- Kim-Ee

From douglas.mcilroy at dartmouth.edu  Wed Dec  8 15:29:35 2021
From: douglas.mcilroy at dartmouth.edu (Douglas McIlroy)
Date: Wed, 8 Dec 2021 10:29:35 -0500
Subject: [Haskell-cafe] Re Is the Haskell list comprehension just a
	Cartesian product machine?
Message-ID: <CAKH6PiXP9RNEwDCBEfm2RtxhcxK2_B3=aWsQTREvO__igQq28A@mail.gmail.com>

> 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

From b at chreekat.net  Wed Dec  8 19:06:15 2021
From: b at chreekat.net (Bryan Richter)
Date: Wed, 8 Dec 2021 21:06:15 +0200
Subject: [Haskell-cafe] Missing messages in the ML
In-Reply-To: <CAM8RHpENNnBizbLQQ2V+fuDjBPCpHuzoTyy3BWuq_gdku=mejg@mail.gmail.com>
References: <CAE1pOi1gd6XYPo6WQPk7=qnV0dqxqoBiSVty_NdTMhc=dFtDSQ@mail.gmail.com>
 <20211121181816.GA20276@cloudinit-builder>
 <24930af1-7f3e-e162-f6d9-965468101bc0@durchholz.org>
 <CC86A6DC-CBD7-4CE0-BDE7-27FE5DF5965F@gmail.com>
 <CAH9BU=zSNSgJKSSofbtw4dCzUVpkg7UBjtFYm57V6ZwYV3DbjQ@mail.gmail.com>
 <CAPY+ZdR3qRcM4wBtu_r4HFEgzq82N6JM8qSz0rFRNu=TH7YLzw@mail.gmail.com>
 <Ojb60d4gH_G4ptYZPTEeUAfUqFSRjkc2RPLgwJ3mSumYwaCJgr5TRNhq0MYO6LE6hdREEAYCj3SKiCkH-415M4DofSR4mcy1pw4RMCPvSqw=@tomsmeding.com>
 <YZtQhrPc83PyVfL1@straasha.imrryr.org>
 <CAM8RHpHChMD_auQ6UZzMdzR+-zWov9dyGF+uN5Gny+RtBqq6+w@mail.gmail.com>
 <CAPY+ZdQtmcGSTbmzhfXEpp+Db1T1PaaGTnitn82qUs+_Vc076Q@mail.gmail.com>
 <CAM8RHpENNnBizbLQQ2V+fuDjBPCpHuzoTyy3BWuq_gdku=mejg@mail.gmail.com>
Message-ID: <CAH9BU=zRx1FDkCJkGd5UKnzxGFseXCiNsGg3tjURd208XUhbfA@mail.gmail.com>

Thanks for your efforts! It's definitely a black art.

On Wed, 8 Dec 2021, 6.43 Gershom B, <gershomb at gmail.com> wrote:

> We migrated our secondary mail server, and have been working on
> bringing its reputation back up. As Viktor diagnosed, it also had a
> sending IP that did not have a PTR record, and that should now be
> resolved, as of last week. But I realized just now that the ptr and
> fwd lookup also have to correspond exactly, which they did not. That
> should also be now fixed. Further, I've tried to turn off sending most
> of our mailinglists through the secondary server, while the
> configuration settles down further. Apologies for the delays --
> getting a proper email host set up and acquiring proper reputation is
> a rather expert task, and I'm far from an expert.
>
> Cheers,
> Gershom
>
> On Tue, Dec 7, 2021 at 11:12 PM Kim-Ee Yeoh <ky3 at atamo.com> wrote:
> >
> > Mailman still isn’t reflecting all mail. Just recently, this arrived in
> my email:
> >
> >
> https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134940.html
> >
> > But not the earlier two posts in the same thread:
> >
> >
> https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134938.html
> >
> https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134939.html
> >
> > What has changed in the email infrastructure recently?
> >
> > On Mon, Nov 22, 2021 at 10:18 PM Gershom B <gershomb at gmail.com> wrote:
> >>
> >> Thanks! We're looking into this with our host.
> >>
> >> -g
> >>
> >> On Mon, Nov 22, 2021 at 3:34 AM Viktor Dukhovni <ietf-dane at dukhovni.org>
> wrote:
> >> >
> >> > On Mon, Nov 22, 2021 at 07:33:43AM +0000, Tom Smeding wrote:
> >> >
> >> > > I got at least one message from Tom Ellis in the Logging
> conversation,
> >> > > one from Joachim Durchholz, and some more. I'm definitely not
> included
> >> > > in the conversation personnally.
> >> > >
> >> > > I have no idea what might be going wrong, but I think it's not
> >> > > forgetting to reply to all.
> >> >
> >> > [ TL;DR haskell.org DNS is misconfigured ]
> >> >
> >> > I guess I can put my SMTP/DNS guru hat on and explain what is
> happening.
> >> > Here's some (cryptic) data from my logs:
> >> >
> >> >     Nov 22 01:42:13 straasha postfix/smtpd[52426]:
> >> >         disconnect from unknown[145.40.99.54]
> >> >         ehlo=2 starttls=1 mail=1
> >> > -->     rcpt=0/1 data=0/1 rset=1 quit=1 commands=6/8
> >> >
> >> >     Nov 22 02:19:13 straasha postfix/smtpd[52686]:
> >> >         disconnect from unknown[2604:1380:4641:a100::5]
> >> >         ehlo=2 starttls=1 mail=1 rcpt=1 data=1 quit=1 commands=7
> >> >
> >> >     Nov 22 02:35:10 straasha postfix/smtpd[53049]:
> >> >         disconnect from unknown[2604:1380:4641:a100::5]
> >> >         ehlo=2 starttls=1 mail=1 rcpt=1 data=1 quit=1 commands=7
> >> >
> >> >     Nov 22 02:42:51 straasha postfix/smtpd[53100]:
> >> >         disconnect from unknown[145.40.99.54]
> >> >         ehlo=2 starttls=1 mail=1
> >> > -->     rcpt=0/1 data=0/1 rset=1 quit=1 commands=6/8
> >> >
> >> > The first and last message were rejected: "rcpt=0/1, data=0/1" mean
> that
> >> > "RCPT TO" and "DATA" commands were refused.  The middle two messages
> >> > were accepted.
> >> >
> >> > The reason is DNS misconfiguration of the of mta1.haskell.org:
> >> >
> >> >     $ set -- mta1.haskell.org
> misc-services-origin-migration.haskell.org
> >> >     $ brief() { dig +noall +ans +nocl +nottl "$@"; }
> >> >     $ echo; for fwd; do brief -t a $fwd; brief -t aaaa $fwd; done
> >> >
> >> >     mta1.haskell.org.   A       145.40.99.54
> >> >
> >> >     $ brief() { dig +noall +ans +nocl +nottl "$@"; }
> >> >     $ set -- 145.40.99.54 2604:1380:4641:a100::5
> >> >     $ echo; for rev; do brief -t ptr -x $rev; done
> >> >
> >> >
>  5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.a.1.4.6.4.0.8.3.1.4.0.6.2.ip6.arpa.
> PTR misc-services-origin-migration.haskell.org.
> >> >
> >> > Only the IPv6 address has a PTR record, and even then it does not
> >> > forward resolve.  SMTP clients with no PTR records are routinely
> refused
> >> > service.  My mail server tolerates lack of forward mappings, but the
> PTR
> >> > is required.
> >> >
> >> > The correct DNS configuration would be:
> >> >
> >> >     forward zone:
> >> >         mta1.haskell.org.   A       145.40.99.54
> >> >         mta1.haskell.org.   AAAA    2604:1380:4641:a100::5
> >> >
> >> >     reverse IPv6 zone
> >> >
>  5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.a.1.4.6.4.0.8.3.1.4.0.6.2.ip6.arpa.
> PTR mta1.haskell.org.
> >> >
> >> >     reverse IPv4 zone
> >> >         54.99.40.145.in-addr.arpa. PTR mta.haskell.org.
> >> >
> >> > --
> >> >     Viktor.
> >> _______________________________________________
> >> Haskell-Cafe mailing list
> >> To (un)subscribe, modify options or view archives go to:
> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> >> Only members subscribed via the mailman list are allowed to post.
> >
> > --
> > -- Kim-Ee
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211208/53b0ee4b/attachment.html>

From icfp.publicity at googlemail.com  Wed Dec  8 20:01:05 2021
From: icfp.publicity at googlemail.com (Ilya Sergey)
Date: Thu, 09 Dec 2021 04:01:05 +0800
Subject: [Haskell-cafe] Call for Workshop Proposals: ICFP 2022
Message-ID: <61b10f0186e1f_15adc3fdd9842ffd0573c3@ilya-work-macbook.mail>

        CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS
                            ICFP 2022
 27th ACM SIGPLAN International Conference on Functional Programming


                      September 11 - 16, 2022
                        Ljubljana, Slovenia
                    https://icfp22.sigplan.org/

The 27th ACM SIGPLAN International Conference on Functional
Programming will be held in Ljubljana, Slovenia on September 11 - 16,
2022, with the option of virtual participation. ICFP provides a forum
for researchers and developers to hear about the latest work on the
design, implementations, principles, and uses of functional
programming.

Proposals are invited for workshops (and other co-located events, such
as symposiums) to be affiliated with ICFP 2022 and sponsored by
SIGPLAN. These events should be less formal and more focused than ICFP
itself, include sessions that enable interaction among the attendees,
and foster the exchange of new ideas. The preference is for one-day
events, but other schedules can also be considered.

The workshops are scheduled to occur on September 11th (the day before
ICFP) and September 15-16th (the two days after ICFP).

----------------------------------------------------------------------

Submission details
 Deadline for submission:     December 24, 2021
 Notification of acceptance:  January  10, 2022

Prospective organizers of workshops or other co-located events are
invited to submit a completed workshop proposal form in plain text
format to the ICFP 2022 workshop co-chairs (Arthur Azevedo de Amorim
and Zoe Paraskevopoulou) via email to

   icfp-workshops-2022 at googlegroups.com

by December 24, 2021. (For proposals of co-located events other than
workshops, please fill in the workshop proposal form and just leave
blank any sections that do not apply.) Please note that this is a firm
deadline.

Organizers will be notified if their event proposal is accepted by
January 10, 2022, and if successful, depending on the event, they
will be asked to produce a final report after the event has taken
place that is suitable for publication in SIGPLAN Notices.

The proposal form is available at:

http://www.icfpconference.org/icfp2022-files/icfp22-workshops-form.txt

Further information about SIGPLAN sponsorship is available at:

http://www.sigplan.org/Resources/Proposals/Sponsored/

----------------------------------------------------------------------

Selection committee

The proposals will be evaluated by a committee comprising the
following members of the ICFP 2022 organizing committee, together with
the members of the SIGPLAN executive committee.

 Workshop Co-Chair: Arthur Azevedo de Amorim       (Boston University)
 Workshop Co-Chair: Zoe Paraskevopoulou      (Northeastern University)
 General Chair:     Andrej Bauer             (University of Ljubljana)
 Program Chair:     Zena Ariola                 (University of Oregon)


----------------------------------------------------------------------

Further information

Any queries should be addressed to the workshop co-chairs (Arthur
Azevedo de Amorim and Zoe Paraskevopoulou), via email to
icfp-workshops-2022 at googlegroups.com.





From david.feuer at gmail.com  Fri Dec 10 15:24:10 2021
From: david.feuer at gmail.com (David Feuer)
Date: Fri, 10 Dec 2021 10:24:10 -0500
Subject: [Haskell-cafe] Priority queue benchmarks
Message-ID: <CAMgWh9t0ryzReE3uc3QLv3o3NfqP-3XbwdqrrsrfD29ubZ4dHg@mail.gmail.com>

I've started working on performance of the venerable but somewhat neglected
pqueue package. The changes I've made so far are pretty obviously good, and
make a big difference in even the most informal testing. But to make
decisions about smaller points, I really need benchmarks, and the package
has none. Does anyone know of a benchmark suite for priority queues? One
that includes algorithms that involve persistent queue use would be
particularly desirable, but I'll take anything.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211210/4a678c5a/attachment.html>

From dyaitskov at gmail.com  Sun Dec 12 20:01:41 2021
From: dyaitskov at gmail.com (Daneel Yaitskov)
Date: Sun, 12 Dec 2021 15:01:41 -0500
Subject: [Haskell-cafe]  GHC debug plugin
Message-ID: <CACNT4y6XA-SPDQMkKS7vxG5DkkHG1NQrP+BnXpNxxbkWsrs7-g@mail.gmail.com>

Hi,

I would like to enable stack traces at launch time and run program without
HasCallStack overhead by default.
I've got an idea to use GHC plugin which would duplicate all functions in
modules with specified prefix. Duplicated functions should get
disambiguating prefix (e.g. "debug") and HasCallStack constraint. Bodies of
prefixed functions should be rewritten to use prefixed functions from
matching modules (should be easy to do - hook just after renaming GHC phase
when all names are fully qualified?).

This way main function could choose "runLib" or "debugRunLib".

Did anybody make something similar?



-- 

Best regards,
Daniil Iaitskov
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211212/a08a8533/attachment.html>

From vamchale at gmail.com  Sun Dec 12 20:53:51 2021
From: vamchale at gmail.com (Vanessa McHale)
Date: Sun, 12 Dec 2021 14:53:51 -0600
Subject: [Haskell-cafe] GHC debug plugin
In-Reply-To: <CACNT4y6XA-SPDQMkKS7vxG5DkkHG1NQrP+BnXpNxxbkWsrs7-g@mail.gmail.com>
References: <CACNT4y6XA-SPDQMkKS7vxG5DkkHG1NQrP+BnXpNxxbkWsrs7-g@mail.gmail.com>
Message-ID: <ba50d069-24ca-5574-03c3-5a312e7cf2e5@gmail.com>

Have you tried the -xc flag yet?

If you do a profiling build and then run your program with +RTS -xc it
will give a stack trace on exceptions.

(I think your idea still has some content but ^ is easier because it
already exists!)

On 12/12/21 2:01 PM, Daneel Yaitskov wrote:
> Hi,
>
> I would like to enable stack traces at launch time and run program
> without HasCallStack overhead by default.
> I've got an idea to use GHC plugin which would duplicate all functions
> in modules with specified prefix. Duplicated functions should get
> disambiguating prefix (e.g. "debug") and HasCallStack constraint.
> Bodies of prefixed functions should be rewritten to use prefixed
> functions from matching modules (should be easy to do - hook just
> after renaming GHC phase when all names are fully qualified?).
>
> This way main function could choose "runLib" or "debugRunLib".
>
> Did anybody make something similar?
>
>
>
> -- 
>
> Best regards,
> Daniil Iaitskov
>  
>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211212/b8b573ed/attachment.html>

From howard.b.golden at gmail.com  Sun Dec 12 22:00:21 2021
From: howard.b.golden at gmail.com (howard.b.golden at gmail.com)
Date: Sun, 12 Dec 2021 14:00:21 -0800
Subject: [Haskell-cafe] Wiki account request
In-Reply-To: <CAJ24hz+JRsHU5Djz6jPK+L4OPOTPSRhsKj=cbswt9BpP1YtCyA@mail.gmail.com>
References: <CAJ24hz+JRsHU5Djz6jPK+L4OPOTPSRhsKj=cbswt9BpP1YtCyA@mail.gmail.com>
Message-ID: <e4530d4cb1803bc118e3d5495aa5f62326411cc6.camel@gmail.com>

Hi Hyeon,

I have created your Haskell wiki account. You should receive a
temporary password by separate email. Please let me know if you have
any problems. 

Regards,
Howard

On Mon, 2021-12-13 at 06:05 +0900, 김지현 wrote:
> Hi folks,
> 
> I'd like to create a new haskell wiki account with a username
> "simnalamburt". At first, I tried to send an email to the "wiki-
> account-request" mailing list as written in 
> https://wiki.haskell.org/index.php?title=Special:UserLogin, but I
> couldn't find the mailing list. If that mailing list is gone, I think
> the notice in the login page should be updated.
> 
> If creating a wiki account takes a long time, can anyone do me a
> favor? I just want to change the outdated link "Using haskell-
> language-server with Vim or NeoVim." in the 
> https://wiki.haskell.org/Vim page to point to 
> https://haskell-language-server.readthedocs.io/en/latest/configuration.html#vim-or-neovim
> .
> 
> Best,
> Hyeon Kim


From dyaitskov at gmail.com  Mon Dec 13 00:54:34 2021
From: dyaitskov at gmail.com (Daneel Yaitskov)
Date: Sun, 12 Dec 2021 19:54:34 -0500
Subject: [Haskell-cafe] GHC debug plugin
In-Reply-To: <ba50d069-24ca-5574-03c3-5a312e7cf2e5@gmail.com>
References: <CACNT4y6XA-SPDQMkKS7vxG5DkkHG1NQrP+BnXpNxxbkWsrs7-g@mail.gmail.com>
 <ba50d069-24ca-5574-03c3-5a312e7cf2e5@gmail.com>
Message-ID: <CACNT4y55XBrenyvO9Ti6LPrQBNgRrL4CQ8t6x4C-Xv8d26ZZFA@mail.gmail.com>

On Sun, Dec 12, 2021 at 3:54 PM Vanessa McHale <vamchale at gmail.com> wrote:

> Have you tried the -xc flag yet?
>
> Thanks for -xc option. Does program run without CPU overhead when -xc is
off? I see that object file must be bigger, but CPU/RAM requirement is not
clear.
-xc has an issue <https://gitlab.haskell.org/ghc/ghc/-/issues/20536> I
encountered recently. Some libraries (e.g. directory) use exceptions for
normal control flow.
So lots of stack traces could be produced. There is no control over what
exception stack trace should be displayed.
The app is based on a Haskell interpreter to run user scripts.
It would be hard to understand such output for users.

If you do a profiling build and then run your program with +RTS -xc it will
> give a stack trace on exceptions.
>
> (I think your idea still has some content but ^ is easier because it
> already exists!)
> On 12/12/21 2:01 PM, Daneel Yaitskov wrote:
>
> Hi,
>
> I would like to enable stack traces at launch time and run program without
> HasCallStack overhead by default.
> I've got an idea to use GHC plugin which would duplicate all functions in
> modules with specified prefix. Duplicated functions should get
> disambiguating prefix (e.g. "debug") and HasCallStack constraint. Bodies of
> prefixed functions should be rewritten to use prefixed functions from
> matching modules (should be easy to do - hook just after renaming GHC phase
> when all names are fully qualified?).
>
> This way main function could choose "runLib" or "debugRunLib".
>
> Did anybody make something similar?
>
>
>
> --
>
> Best regards,
> Daniil Iaitskov
>
>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.



-- 

Best regards,
Daniil Iaitskov
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211212/d2761e2a/attachment.html>

From olf at aatal-apotheke.de  Mon Dec 13 12:49:19 2021
From: olf at aatal-apotheke.de (Olaf Klinke)
Date: Mon, 13 Dec 2021 13:49:19 +0100
Subject: [Haskell-cafe] DataKinds and Data.Char
Message-ID: <bb197d02495949f3a283a7491d8e1f6ad4df8328.camel@aatal-apotheke.de>

Dear Café,

Question: Is DataKinds promotion of Char values possible, and if yes,
how? 

I want to define a data type of text where a certain character has
special meaning. I could say:
    data SpecialText = SpecialText Char Text
but it would be favourable if the type system forbids combining texts
with distinct special characters. 
    data SpecialText char = SpecialText Text
Ideally, we could use DataKinds to specialize the char phantom type
parameter to a promoted Char value, but neither 'x' nor ''x' is
accepted by GHC, presumably for good reasons. After all, 'x' is
syntactic sugar for the real constructor of a Char value (which is
what? Data.Data.toConstr 'x' yields 'x'.)

One certainly can define data types symbolizing selected single Char
values to use as the phantom type, but that means the library author
decides which Chars the user can declare as special. 

Thanks
Olaf


From oleg.grenrus at iki.fi  Mon Dec 13 13:21:11 2021
From: oleg.grenrus at iki.fi (Oleg Grenrus)
Date: Mon, 13 Dec 2021 15:21:11 +0200
Subject: [Haskell-cafe] DataKinds and Data.Char
In-Reply-To: <bb197d02495949f3a283a7491d8e1f6ad4df8328.camel@aatal-apotheke.de>
References: <bb197d02495949f3a283a7491d8e1f6ad4df8328.camel@aatal-apotheke.de>
Message-ID: <211ce9fa-732b-087f-221f-8f1019b8b98b@iki.fi>

Yes

https://github.com/ghc-proposals/ghc-proposals/pull/387
Implemented in GHC-9.2

- Oleg

On 13.12.2021 14.49, Olaf Klinke wrote:
> Dear Café,
>
> Question: Is DataKinds promotion of Char values possible, and if yes,
> how? 
>
> I want to define a data type of text where a certain character has
> special meaning. I could say:
>     data SpecialText = SpecialText Char Text
> but it would be favourable if the type system forbids combining texts
> with distinct special characters. 
>     data SpecialText char = SpecialText Text
> Ideally, we could use DataKinds to specialize the char phantom type
> parameter to a promoted Char value, but neither 'x' nor ''x' is
> accepted by GHC, presumably for good reasons. After all, 'x' is
> syntactic sugar for the real constructor of a Char value (which is
> what? Data.Data.toConstr 'x' yields 'x'.)
>
> One certainly can define data types symbolizing selected single Char
> values to use as the phantom type, but that means the library author
> decides which Chars the user can declare as special. 
>
> Thanks
> Olaf
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.

From joshchia at gmail.com  Mon Dec 13 15:56:29 2021
From: joshchia at gmail.com (=?UTF-8?B?4piCSm9zaCBDaGlhICjorJ3ku7vkuK0p?=)
Date: Mon, 13 Dec 2021 23:56:29 +0800
Subject: [Haskell-cafe] ImplicitParams in GHC 9.0.1
Message-ID: <CALxtSbR3BAke8Dwx-Pw0oWL6k4rLdBaKF+DSb=paeHaLo6v6Hg@mail.gmail.com>

Hi,

I have the following code that builds successfully with "stack build" under
GHC 8.10.7 but fails to build under GHC 9.0.1:

https://github.com/jchia/ip-bug

The compiler is switched by commenting/uncommenting the compiler line in
stack.yaml.

GHC 9.0.1 gives me the error I paste at the end. Is this expected (maybe as
part of "simplified subsumtion" in
https://gitlab.haskell.org/ghc/ghc/-/wikis/migration/9.0#compiler-changes)?
If so, how can the code be fixed? If not, is it a compiler bug?

(This problem came up while using gi-gtk-3.0.38, where implicit params are
used a lot).

Josh

/home/jchia/gh/ip-bug/src/Lib.hs:10:28: error:
    • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
      Expected: Int -> Char -> Char
        Actual: Int -> ((?self::Int) => Char) -> Char
    • In the expression: foo
      In the expression: (let ?self = x in foo) :: Int -> Char -> Char
      In the expression:
        ((let ?self = x in foo) :: Int -> Char -> Char) x
   |
10 | bar x = ((let ?self = x in foo) :: Int -> Char -> Char) x
   |                            ^^^

/home/jchia/gh/ip-bug/src/Lib.hs:13:26: error:
    • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
      Expected: Char -> Char
        Actual: ((?self::Int) => Char) -> Char
    • In the expression: foo x
      In the expression: let ?self = x in foo x
      In an equation for ‘baz’: baz x = let ?self = x in foo x
   |
13 | baz x = let ?self = x in foo x
   |                          ^^^^^
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211213/36a2a548/attachment.html>

From godzbanebane at gmail.com  Mon Dec 13 16:13:13 2021
From: godzbanebane at gmail.com (Georgi Lyubenov)
Date: Mon, 13 Dec 2021 18:13:13 +0200
Subject: [Haskell-cafe] ImplicitParams in GHC 9.0.1
In-Reply-To: <CALxtSbR3BAke8Dwx-Pw0oWL6k4rLdBaKF+DSb=paeHaLo6v6Hg@mail.gmail.com>
References: <CALxtSbR3BAke8Dwx-Pw0oWL6k4rLdBaKF+DSb=paeHaLo6v6Hg@mail.gmail.com>
Message-ID: <CABT0e9oMZ2zMaEd36R_bMsEQVgYR=VCNXnWos8x4Hr4BoTTK_A@mail.gmail.com>

Hey!

I'd say 'yes' seeing as how eta expanding the function works:

{-# LANGUAGE ImplicitParams #-}
{-# LANGUAGE RankNTypes #-}

module Lib where

foo :: Int -> ((?self :: Int) => Char) -> Char
foo x y = undefined

bar :: Int -> (Char -> Char)
bar x = (let ?self = x in (\u v -> foo u v)) x

baz :: Int -> (Char -> Char)
baz x c = let ?self = x in foo x c

However, I think it's still worth issuing a ghc bug report for this, as it
seems to really hurt implicit param usability in this case

Cheers,

Georgi

On Mon, Dec 13, 2021 at 5:57 PM ☂Josh Chia (謝任中) <joshchia at gmail.com> wrote:

> Hi,
>
> I have the following code that builds successfully with "stack build"
> under GHC 8.10.7 but fails to build under GHC 9.0.1:
>
> https://github.com/jchia/ip-bug
>
> The compiler is switched by commenting/uncommenting the compiler line in
> stack.yaml.
>
> GHC 9.0.1 gives me the error I paste at the end. Is this expected (maybe
> as part of "simplified subsumtion" in
> https://gitlab.haskell.org/ghc/ghc/-/wikis/migration/9.0#compiler-changes)?
> If so, how can the code be fixed? If not, is it a compiler bug?
>
> (This problem came up while using gi-gtk-3.0.38, where implicit params are
> used a lot).
>
> Josh
>
> /home/jchia/gh/ip-bug/src/Lib.hs:10:28: error:
>     • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
>       Expected: Int -> Char -> Char
>         Actual: Int -> ((?self::Int) => Char) -> Char
>     • In the expression: foo
>       In the expression: (let ?self = x in foo) :: Int -> Char -> Char
>       In the expression:
>         ((let ?self = x in foo) :: Int -> Char -> Char) x
>    |
> 10 | bar x = ((let ?self = x in foo) :: Int -> Char -> Char) x
>    |                            ^^^
>
> /home/jchia/gh/ip-bug/src/Lib.hs:13:26: error:
>     • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
>       Expected: Char -> Char
>         Actual: ((?self::Int) => Char) -> Char
>     • In the expression: foo x
>       In the expression: let ?self = x in foo x
>       In an equation for ‘baz’: baz x = let ?self = x in foo x
>    |
> 13 | baz x = let ?self = x in foo x
>    |                          ^^^^^
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211213/a6a04482/attachment.html>

From david.feuer at gmail.com  Mon Dec 13 16:23:59 2021
From: david.feuer at gmail.com (David Feuer)
Date: Mon, 13 Dec 2021 11:23:59 -0500
Subject: [Haskell-cafe] ImplicitParams in GHC 9.0.1
In-Reply-To: <CABT0e9oMZ2zMaEd36R_bMsEQVgYR=VCNXnWos8x4Hr4BoTTK_A@mail.gmail.com>
References: <CALxtSbR3BAke8Dwx-Pw0oWL6k4rLdBaKF+DSb=paeHaLo6v6Hg@mail.gmail.com>
 <CABT0e9oMZ2zMaEd36R_bMsEQVgYR=VCNXnWos8x4Hr4BoTTK_A@mail.gmail.com>
Message-ID: <CAMgWh9v4uHbQ9MRAw9R-_oyX=vvYkreumb-kkXfWY=6tm4uuhA@mail.gmail.com>

It's also really bad for the (new!) LinearTypes extension, since we can't
pass x %1-> y where it expects x -> y. We have to eta expand. Ugh.

On Mon, Dec 13, 2021, 11:14 AM Georgi Lyubenov <godzbanebane at gmail.com>
wrote:

> Hey!
>
> I'd say 'yes' seeing as how eta expanding the function works:
>
> {-# LANGUAGE ImplicitParams #-}
> {-# LANGUAGE RankNTypes #-}
>
> module Lib where
>
> foo :: Int -> ((?self :: Int) => Char) -> Char
> foo x y = undefined
>
> bar :: Int -> (Char -> Char)
> bar x = (let ?self = x in (\u v -> foo u v)) x
>
> baz :: Int -> (Char -> Char)
> baz x c = let ?self = x in foo x c
>
> However, I think it's still worth issuing a ghc bug report for this, as it
> seems to really hurt implicit param usability in this case
>
> Cheers,
>
> Georgi
>
> On Mon, Dec 13, 2021 at 5:57 PM ☂Josh Chia (謝任中) <joshchia at gmail.com>
> wrote:
>
>> Hi,
>>
>> I have the following code that builds successfully with "stack build"
>> under GHC 8.10.7 but fails to build under GHC 9.0.1:
>>
>> https://github.com/jchia/ip-bug
>>
>> The compiler is switched by commenting/uncommenting the compiler line in
>> stack.yaml.
>>
>> GHC 9.0.1 gives me the error I paste at the end. Is this expected (maybe
>> as part of "simplified subsumtion" in
>> https://gitlab.haskell.org/ghc/ghc/-/wikis/migration/9.0#compiler-changes)?
>> If so, how can the code be fixed? If not, is it a compiler bug?
>>
>> (This problem came up while using gi-gtk-3.0.38, where implicit params
>> are used a lot).
>>
>> Josh
>>
>> /home/jchia/gh/ip-bug/src/Lib.hs:10:28: error:
>>     • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
>>       Expected: Int -> Char -> Char
>>         Actual: Int -> ((?self::Int) => Char) -> Char
>>     • In the expression: foo
>>       In the expression: (let ?self = x in foo) :: Int -> Char -> Char
>>       In the expression:
>>         ((let ?self = x in foo) :: Int -> Char -> Char) x
>>    |
>> 10 | bar x = ((let ?self = x in foo) :: Int -> Char -> Char) x
>>    |                            ^^^
>>
>> /home/jchia/gh/ip-bug/src/Lib.hs:13:26: error:
>>     • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
>>       Expected: Char -> Char
>>         Actual: ((?self::Int) => Char) -> Char
>>     • In the expression: foo x
>>       In the expression: let ?self = x in foo x
>>       In an equation for ‘baz’: baz x = let ?self = x in foo x
>>    |
>> 13 | baz x = let ?self = x in foo x
>>    |                          ^^^^^
>> _______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>> Only members subscribed via the mailman list are allowed to post.
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211213/5b463dec/attachment.html>

From joshchia at gmail.com  Mon Dec 13 16:51:06 2021
From: joshchia at gmail.com (=?UTF-8?B?4piCSm9zaCBDaGlhICjorJ3ku7vkuK0p?=)
Date: Tue, 14 Dec 2021 00:51:06 +0800
Subject: [Haskell-cafe] ImplicitParams in GHC 9.0.1
In-Reply-To: <CAMgWh9v4uHbQ9MRAw9R-_oyX=vvYkreumb-kkXfWY=6tm4uuhA@mail.gmail.com>
References: <CALxtSbR3BAke8Dwx-Pw0oWL6k4rLdBaKF+DSb=paeHaLo6v6Hg@mail.gmail.com>
 <CABT0e9oMZ2zMaEd36R_bMsEQVgYR=VCNXnWos8x4Hr4BoTTK_A@mail.gmail.com>
 <CAMgWh9v4uHbQ9MRAw9R-_oyX=vvYkreumb-kkXfWY=6tm4uuhA@mail.gmail.com>
Message-ID: <CALxtSbRHULkjmM7cWJ15cuDnDbi6gLFBQDLfjnH81r+RSjffOQ@mail.gmail.com>

I just file a feature request issue:

https://gitlab.haskell.org/ghc/ghc/-/issues/20818

On Tue, Dec 14, 2021 at 12:24 AM David Feuer <david.feuer at gmail.com> wrote:

> It's also really bad for the (new!) LinearTypes extension, since we can't
> pass x %1-> y where it expects x -> y. We have to eta expand. Ugh.
>
> On Mon, Dec 13, 2021, 11:14 AM Georgi Lyubenov <godzbanebane at gmail.com>
> wrote:
>
>> Hey!
>>
>> I'd say 'yes' seeing as how eta expanding the function works:
>>
>> {-# LANGUAGE ImplicitParams #-}
>> {-# LANGUAGE RankNTypes #-}
>>
>> module Lib where
>>
>> foo :: Int -> ((?self :: Int) => Char) -> Char
>> foo x y = undefined
>>
>> bar :: Int -> (Char -> Char)
>> bar x = (let ?self = x in (\u v -> foo u v)) x
>>
>> baz :: Int -> (Char -> Char)
>> baz x c = let ?self = x in foo x c
>>
>> However, I think it's still worth issuing a ghc bug report for this, as
>> it seems to really hurt implicit param usability in this case
>>
>> Cheers,
>>
>> Georgi
>>
>> On Mon, Dec 13, 2021 at 5:57 PM ☂Josh Chia (謝任中) <joshchia at gmail.com>
>> wrote:
>>
>>> Hi,
>>>
>>> I have the following code that builds successfully with "stack build"
>>> under GHC 8.10.7 but fails to build under GHC 9.0.1:
>>>
>>> https://github.com/jchia/ip-bug
>>>
>>> The compiler is switched by commenting/uncommenting the compiler line in
>>> stack.yaml.
>>>
>>> GHC 9.0.1 gives me the error I paste at the end. Is this expected (maybe
>>> as part of "simplified subsumtion" in
>>> https://gitlab.haskell.org/ghc/ghc/-/wikis/migration/9.0#compiler-changes)?
>>> If so, how can the code be fixed? If not, is it a compiler bug?
>>>
>>> (This problem came up while using gi-gtk-3.0.38, where implicit params
>>> are used a lot).
>>>
>>> Josh
>>>
>>> /home/jchia/gh/ip-bug/src/Lib.hs:10:28: error:
>>>     • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
>>>       Expected: Int -> Char -> Char
>>>         Actual: Int -> ((?self::Int) => Char) -> Char
>>>     • In the expression: foo
>>>       In the expression: (let ?self = x in foo) :: Int -> Char -> Char
>>>       In the expression:
>>>         ((let ?self = x in foo) :: Int -> Char -> Char) x
>>>    |
>>> 10 | bar x = ((let ?self = x in foo) :: Int -> Char -> Char) x
>>>    |                            ^^^
>>>
>>> /home/jchia/gh/ip-bug/src/Lib.hs:13:26: error:
>>>     • Couldn't match type ‘(?self::Int) => Char’ with ‘Char’
>>>       Expected: Char -> Char
>>>         Actual: ((?self::Int) => Char) -> Char
>>>     • In the expression: foo x
>>>       In the expression: let ?self = x in foo x
>>>       In an equation for ‘baz’: baz x = let ?self = x in foo x
>>>    |
>>> 13 | baz x = let ?self = x in foo x
>>>    |                          ^^^^^
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> To (un)subscribe, modify options or view archives go to:
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>>> Only members subscribed via the mailman list are allowed to post.
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>> Only members subscribed via the mailman list are allowed to post.
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211214/96cff82d/attachment.html>

From john at yourdigitalvoice.net  Tue Dec 14 04:53:54 2021
From: john at yourdigitalvoice.net (John Sinclair)
Date: Tue, 14 Dec 2021 17:53:54 +1300
Subject: [Haskell-cafe] [CFP] Functional Conf 2022 online - have you got
 Haskell insights to share with the community?
Message-ID: <CAAsNZ4VNMrtxH-N_bc6UJw1vcnMGe8WEv7Jm+FzHDfJ-aP2iAQ@mail.gmail.com>

Have you devised an innovative or novel application of Haskell? Have you
solved a tricky problem using FP? This is a great opportunity to share what
you've been working on. If it's related to functional programming, Functional
Conf would love to hear from you!

We are looking for deep technical topics related to Functional Programming.


Learn more and submit your proposal here: https://confng.in/oVspOYAc
<https://llink.to/?u=https:%2F%2Fsignal2domain.online%2Fclick%3Fredirect%3Dhttps%253A%252F%252Fconfng.in%252FoVspOYAc%26dID%3D1639457634867%26linkName%3Dhttps:%2F%2Fconfng.in%2FoVspOYAc&e=7a380914aad66f79b671f4f4b9a345c9>

Submissions close: 15 Jan 2022

Functional Conf is Asia's premiere functional programming conference. The
event runs 24-26 March 2022 and due to COVID uncertainties will be held
online. Over the course of 3 days, you'll get cutting edge insights from
global thought leaders, practitioners and developers from prominent FP
languages (this could be you!). At our last conference Edward Kmett who chairs
the Haskell core libraries committee presented.

The conference is designed to help attendees:

   -

   Understand the fundamental concepts of FP
   -

   Learn how others are leveraging FP to solve real world problems
   -

   Explore practical usages and gotchas in FP concepts from experts
   -

   Exchange real-world experience with your programing peers


If you are just getting started with FP or work with it everyday, you'll
love Functional Conf 2022!

Here's a short video of past speakers sharing a little of their experience
at Functional Conf: https://confng.in/EFX1sthg
<https://llink.to/?u=https:%2F%2Fsignal2domain.online%2Fclick%3Fredirect%3Dhttps%253A%252F%252Fconfng.in%252FEFX1sthg%26dID%3D1639457634867%26linkName%3Dhttps:%2F%2Fconfng.in%2FEFX1sthg&e=7a380914aad66f79b671f4f4b9a345c9>

Submit your proposal here: https://confng.in/JzhW9cSX
<https://llink.to/?u=https:%2F%2Fsignal2domain.online%2Fclick%3Fredirect%3Dhttps%253A%252F%252Fconfng.in%252FJzhW9cSX%26dID%3D1639457634867%26linkName%3Dhttps:%2F%2Fconfng.in%2FJzhW9cSX&e=7a380914aad66f79b671f4f4b9a345c9>

Hope to see you there!

Best regards, John Sinclair and the Functional Conf Team
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211214/ed2d8722/attachment.html>

From robstewart57 at gmail.com  Tue Dec 14 12:25:25 2021
From: robstewart57 at gmail.com (Rob Stewart)
Date: Tue, 14 Dec 2021 12:25:25 +0000
Subject: [Haskell-cafe] Postdoc position - hardware acceleration of Haskell
Message-ID: <CA+ZOasLBsCv2CvgdxnwooONsLQLwvuEbLgYUkCb80XHwA12Y2A@mail.gmail.com>

Hi haskell-cafe,

I have an opening for a postdoc position at Heriot-Watt University in
Edinburgh, on hardware acceleration of functional programming
languages. In particular, Haskell.

Candidates should have a background in hardware design and FPGA
programming. Hardware engineering experience should include circuit
design, developing processor architectures, memory hierarchies and/or
instruction sets. Candidates should have some understanding of
functional programming. Programming language implementation experience
is desirable, but not essential. The role will involve developing a
special purpose processor for Haskell, aimed at outperforming the
throughput and energy performance of CPUs. The project has close
industry ties in Ireland and the Netherlands.

It is a three year project, starting in May 2022.

The HAFLANG project:

  https://haflang.github.io

Job details and application form:

  https://enzj.fa.em3.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX/job/1716/

The application deadline is 28th February 2022.

Contact the PI, Rob Stewart, with inquiries (R.Stewart at hw.ac.uk).

Please share this widely.

--
Rob Stewart
Assistant Professor of Computer Science
Heriot-Watt University, Edinburgh
W: https://www.macs.hw.ac.uk/~rs46

From fumiexcel at gmail.com  Wed Dec 15 06:39:39 2021
From: fumiexcel at gmail.com (Fumiaki Kinoshita)
Date: Wed, 15 Dec 2021 15:39:39 +0900
Subject: [Haskell-cafe] Package takeover request for oath
In-Reply-To: <CAATCwU=MGkR4XEHB+Jy2K7X+QCCkv81-XV=qcFN0m8C0USecUQ@mail.gmail.com>
References: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
 <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>
 <a16caa84-228f-3b25-d304-43f3107eaac0@glitchbra.in>
 <CAATCwU=MGkR4XEHB+Jy2K7X+QCCkv81-XV=qcFN0m8C0USecUQ@mail.gmail.com>
Message-ID: <CAATCwUmOOpHvthiJcNWWzEeM4N_GTz_-iddZXP7d9ohH3U-bAQ@mail.gmail.com>

Sorry to bother you again. Any thoughts?

2021年12月8日(水) 10:45 Fumiaki Kinoshita <fumiexcel at gmail.com>:

> OK. Hackage admin, could you either remove the release candidate for oath,
> or add me to the list of maintainers?
>
> 2021年12月6日(月) 17:19 Hécate <hecate at glitchbra.in>:
>
>> Hi Fumiaki,
>>
>> hvr seems to have disengaged from his responsibilities around last year
>> or so.
>> Le 06/12/2021 à 08:00, Fumiaki Kinoshita a écrit :
>>
>> CC'd Gershom as the system failed to deliver this mail via hackage-admin.
>>
>> Has anyone heard from hvr? I haven't seen him in a while, either on
>> GitHub or ML
>>
>> 2021年12月5日(日) 11:25 Fumiaki Kinoshita <fumiexcel at gmail.com>:
>>
>>> At the moment, oath is registered as a "reserved package name" (see
>>> https://mail.haskell.org/pipermail/libraries/2021-December/031524.html)
>>> and does not exist as an actual package.
>>>
>>> I'd like to upload a package with this name unless there's a specific
>>> reason why I should not.
>>> My Hackage username is FumiakiKinoshita.
>>>
>>> Best regards,
>>>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>> Only members subscribed via the mailman list are allowed to post.
>>
>> --
>> Hécate ✨
>> 🐦: @TechnoEmpress
>> IRC: Hecate
>> WWW: https://glitchbra.in
>> RUN: BSD
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>> Only members subscribed via the mailman list are allowed to post.
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211215/25f6848b/attachment.html>

From brucker at spamfence.net  Wed Dec 15 10:36:25 2021
From: brucker at spamfence.net (Achim D. Brucker)
Date: Wed, 15 Dec 2021 10:36:25 +0000
Subject: [Haskell-cafe] Fully (UK Home) Funded PhD Positions in the Safety
 and Security of Advanced Systems Group (Exeter, UK, Deadline 2021-01-24)
Message-ID: <YbnFKaI9IBSrOLqW@edogawa.logicalhacking.com>


Several fully funded PhD scholarships for UK applicants are available 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),
  * specification-based testing, and
  * design and implementation of security architectures.

This award provides annual funding to cover UK tuition fees and a
tax-free stipend. For students who pay UK tuition fees the award will
cover the tuition fees in full, plus at least £15,009 per year
tax-free stipend. The studentship will be awarded on the basis of
merit for 3.5 years of full-time study.

Interested candidates should contact the potential supervisors
Prof. Achim Brucker (a.brucker at exeter.ac.uk) or Dr. Diego Marmsoler
(d.marmsoler at 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
  * Software Engineering for Security- or Safety-Critical Systems:
    https://www.exeter.ac.uk/study/funding/award/?id=4329
  * Open Call:
    https://www.exeter.ac.uk/study/funding/award/?id=4343

The closing date for applications is midnight on the 24th of January 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

From guthrie at miu.edu  Wed Dec 15 17:33:24 2021
From: guthrie at miu.edu (Gregory Guthrie)
Date: Wed, 15 Dec 2021 17:33:24 +0000
Subject: [Haskell-cafe] install error: sym
Message-ID: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>

Seems like this is a package error?
  Sym\Perm\STAT.hs:13:8: error:
    File name does not match module name:
    Saw: `Sym.Perm.Stat'
    Expected: `Sym.Perm.STAT'


Install log:
PS C:\Users\guthrie\Desktop> cabal install sym
Resolving dependencies...
Build profile: -w ghc-8.10.2 -O1
In order, the following will be built (use -v for more details):
- base-orphans-0.8.6 (lib) (requires download & build)
- primitive-0.7.3.0 (lib) (requires download & build)
- hashable-1.4.0.1 (lib) (requires download & build)
- vector-0.12.3.1 (lib) (requires download & build)
- sym-0.13.0 (lib) (requires download & build)
Downloading  base-orphans-0.8.6
Downloaded   base-orphans-0.8.6
Downloading  primitive-0.7.3.0
Starting     base-orphans-0.8.6 (lib)
Downloaded   primitive-0.7.3.0
Downloading  vector-0.12.3.1
Starting     primitive-0.7.3.0 (lib)
Downloaded   vector-0.12.3.1
Downloading  hashable-1.4.0.1
Downloaded   hashable-1.4.0.1
Downloading  sym-0.13.0
Downloaded   sym-0.13.0
Building     base-orphans-0.8.6 (lib)
Building     primitive-0.7.3.0 (lib)
Installing   base-orphans-0.8.6 (lib)
Completed    base-orphans-0.8.6 (lib)
Starting     hashable-1.4.0.1 (lib)
Building     hashable-1.4.0.1 (lib)
Installing   primitive-0.7.3.0 (lib)
Completed    primitive-0.7.3.0 (lib)
Starting     vector-0.12.3.1 (lib)
Installing   hashable-1.4.0.1 (lib)
Building     vector-0.12.3.1 (lib)
Completed    hashable-1.4.0.1 (lib)
Installing   vector-0.12.3.1 (lib)
Completed    vector-0.12.3.1 (lib)
Starting     sym-0.13.0 (lib)
Building     sym-0.13.0 (lib)

Failed to build sym-0.13.0.
Build log (
C:\Users\guthrie\AppData\Roaming\cabal\logs\ghc-8.10.2\sym-0.13.0-6a5a01f540d09f303c049bc421a706632878562d.log
):
Preprocessing library for sym-0.13.0..
Building library for sym-0.13.0..

Sym\Perm\STAT.hs:13:8: error:
    File name does not match module name:
    Saw: `Sym.Perm.Stat'
    Expected: `Sym.Perm.STAT'
   |
13 | module Sym.Perm.Stat
   |        ^^^^^^^^^^^^^
cabal.exe: Failed to build sym-0.13.0. See the build log above for details.

Dr. Gregory Guthrie

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211215/7ade42c4/attachment.html>

From tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk  Wed Dec 15 17:56:55 2021
From: tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk (Tom Ellis)
Date: Wed, 15 Dec 2021 17:56:55 +0000
Subject: [Haskell-cafe] install error: sym
In-Reply-To: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
References: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
Message-ID: <20211215175655.GE14501@cloudinit-builder>

Perhaps this is a Windows-filesystem-case-insensitive issue.  That
package has both `Stat` and `STAT`:

https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-Stat.html

https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-STAT.html

Tom


On Wed, Dec 15, 2021 at 05:33:24PM +0000, Gregory Guthrie wrote:
> Seems like this is a package error?
>   Sym\Perm\STAT.hs:13:8: error:
>     File name does not match module name:
>     Saw: `Sym.Perm.Stat'
>     Expected: `Sym.Perm.STAT'
> 
> 
> Install log:
> PS C:\Users\guthrie\Desktop> cabal install sym
> Resolving dependencies...
> Build profile: -w ghc-8.10.2 -O1
> In order, the following will be built (use -v for more details):
> - base-orphans-0.8.6 (lib) (requires download & build)
> - primitive-0.7.3.0 (lib) (requires download & build)
> - hashable-1.4.0.1 (lib) (requires download & build)
> - vector-0.12.3.1 (lib) (requires download & build)
> - sym-0.13.0 (lib) (requires download & build)
> Downloading  base-orphans-0.8.6
> Downloaded   base-orphans-0.8.6
> Downloading  primitive-0.7.3.0
> Starting     base-orphans-0.8.6 (lib)
> Downloaded   primitive-0.7.3.0
> Downloading  vector-0.12.3.1
> Starting     primitive-0.7.3.0 (lib)
> Downloaded   vector-0.12.3.1
> Downloading  hashable-1.4.0.1
> Downloaded   hashable-1.4.0.1
> Downloading  sym-0.13.0
> Downloaded   sym-0.13.0
> Building     base-orphans-0.8.6 (lib)
> Building     primitive-0.7.3.0 (lib)
> Installing   base-orphans-0.8.6 (lib)
> Completed    base-orphans-0.8.6 (lib)
> Starting     hashable-1.4.0.1 (lib)
> Building     hashable-1.4.0.1 (lib)
> Installing   primitive-0.7.3.0 (lib)
> Completed    primitive-0.7.3.0 (lib)
> Starting     vector-0.12.3.1 (lib)
> Installing   hashable-1.4.0.1 (lib)
> Building     vector-0.12.3.1 (lib)
> Completed    hashable-1.4.0.1 (lib)
> Installing   vector-0.12.3.1 (lib)
> Completed    vector-0.12.3.1 (lib)
> Starting     sym-0.13.0 (lib)
> Building     sym-0.13.0 (lib)
> 
> Failed to build sym-0.13.0.
> Build log (
> C:\Users\guthrie\AppData\Roaming\cabal\logs\ghc-8.10.2\sym-0.13.0-6a5a01f540d09f303c049bc421a706632878562d.log
> ):
> Preprocessing library for sym-0.13.0..
> Building library for sym-0.13.0..
> 
> Sym\Perm\STAT.hs:13:8: error:
>     File name does not match module name:
>     Saw: `Sym.Perm.Stat'
>     Expected: `Sym.Perm.STAT'
>    |
> 13 | module Sym.Perm.Stat
>    |        ^^^^^^^^^^^^^
> cabal.exe: Failed to build sym-0.13.0. See the build log above for details.
> 
> Dr. Gregory Guthrie
> 

> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.


From guthrie at miu.edu  Wed Dec 15 18:08:22 2021
From: guthrie at miu.edu (Gregory Guthrie)
Date: Wed, 15 Dec 2021 18:08:22 +0000
Subject: [Haskell-cafe] install error: sym
In-Reply-To: <20211215175655.GE14501@cloudinit-builder>
References: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <20211215175655.GE14501@cloudinit-builder>
Message-ID: <CH2PR03MB522454375151DB58A35448F5A1769@CH2PR03MB5224.namprd03.prod.outlook.com>

Thank you - seems right; but the installer seems to only try one variant. So any solution for Windows?
:-)


-----Original Message-----
From: Haskell-Cafe <haskell-cafe-bounces at haskell.org> On Behalf Of Tom Ellis
Sent: Wednesday, December 15, 2021 11:57 AM
To: haskell-cafe at haskell.org
Subject: Re: [Haskell-cafe] install error: sym

Perhaps this is a Windows-filesystem-case-insensitive issue.  That package has both `Stat` and `STAT`:

https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-Stat.html

https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-STAT.html

Tom


On Wed, Dec 15, 2021 at 05:33:24PM +0000, Gregory Guthrie wrote:
> Seems like this is a package error?
>   Sym\Perm\STAT.hs:13:8: error:
>     File name does not match module name:
>     Saw: `Sym.Perm.Stat'
>     Expected: `Sym.Perm.STAT'
> 
> 
> Install log:
> PS C:\Users\guthrie\Desktop> cabal install sym Resolving 
> dependencies...
> Build profile: -w ghc-8.10.2 -O1
> In order, the following will be built (use -v for more details):
> - base-orphans-0.8.6 (lib) (requires download & build)
> - primitive-0.7.3.0 (lib) (requires download & build)
> - hashable-1.4.0.1 (lib) (requires download & build)
> - vector-0.12.3.1 (lib) (requires download & build)
> - sym-0.13.0 (lib) (requires download & build) Downloading  
> base-orphans-0.8.6
> Downloaded   base-orphans-0.8.6
> Downloading  primitive-0.7.3.0
> Starting     base-orphans-0.8.6 (lib)
> Downloaded   primitive-0.7.3.0
> Downloading  vector-0.12.3.1
> Starting     primitive-0.7.3.0 (lib)
> Downloaded   vector-0.12.3.1
> Downloading  hashable-1.4.0.1
> Downloaded   hashable-1.4.0.1
> Downloading  sym-0.13.0
> Downloaded   sym-0.13.0
> Building     base-orphans-0.8.6 (lib)
> Building     primitive-0.7.3.0 (lib)
> Installing   base-orphans-0.8.6 (lib)
> Completed    base-orphans-0.8.6 (lib)
> Starting     hashable-1.4.0.1 (lib)
> Building     hashable-1.4.0.1 (lib)
> Installing   primitive-0.7.3.0 (lib)
> Completed    primitive-0.7.3.0 (lib)
> Starting     vector-0.12.3.1 (lib)
> Installing   hashable-1.4.0.1 (lib)
> Building     vector-0.12.3.1 (lib)
> Completed    hashable-1.4.0.1 (lib)
> Installing   vector-0.12.3.1 (lib)
> Completed    vector-0.12.3.1 (lib)
> Starting     sym-0.13.0 (lib)
> Building     sym-0.13.0 (lib)
> 
> Failed to build sym-0.13.0.
> Build log (
> C:\Users\guthrie\AppData\Roaming\cabal\logs\ghc-8.10.2\sym-0.13.0-6a5a
> 01f540d09f303c049bc421a706632878562d.log
> ):
> Preprocessing library for sym-0.13.0..
> Building library for sym-0.13.0..
> 
> Sym\Perm\STAT.hs:13:8: error:
>     File name does not match module name:
>     Saw: `Sym.Perm.Stat'
>     Expected: `Sym.Perm.STAT'
>    |
> 13 | module Sym.Perm.Stat
>    |        ^^^^^^^^^^^^^
> cabal.exe: Failed to build sym-0.13.0. See the build log above for details.
> 
> Dr. Gregory Guthrie
> 

> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.

From allbery.b at gmail.com  Wed Dec 15 18:12:21 2021
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 15 Dec 2021 13:12:21 -0500
Subject: [Haskell-cafe] install error: sym
In-Reply-To: <CH2PR03MB522454375151DB58A35448F5A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
References: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <20211215175655.GE14501@cloudinit-builder>
 <CH2PR03MB522454375151DB58A35448F5A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
Message-ID: <CAKFCL4VtnfxbdLv_J4E4fqYQGAvwj-SfUcAZ388af8o6TRa9Ww@mail.gmail.com>

The installer probably overwrites one with the other, since the
filesystem doesn't know the two are supposed to be different.

On Wed, Dec 15, 2021 at 1:11 PM Gregory Guthrie <guthrie at miu.edu> wrote:
>
> Thank you - seems right; but the installer seems to only try one variant. So any solution for Windows?
> :-)
>
>
> -----Original Message-----
> From: Haskell-Cafe <haskell-cafe-bounces at haskell.org> On Behalf Of Tom Ellis
> Sent: Wednesday, December 15, 2021 11:57 AM
> To: haskell-cafe at haskell.org
> Subject: Re: [Haskell-cafe] install error: sym
>
> Perhaps this is a Windows-filesystem-case-insensitive issue.  That package has both `Stat` and `STAT`:
>
> https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-Stat.html
>
> https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-STAT.html
>
> Tom
>
>
> On Wed, Dec 15, 2021 at 05:33:24PM +0000, Gregory Guthrie wrote:
> > Seems like this is a package error?
> >   Sym\Perm\STAT.hs:13:8: error:
> >     File name does not match module name:
> >     Saw: `Sym.Perm.Stat'
> >     Expected: `Sym.Perm.STAT'
> >
> >
> > Install log:
> > PS C:\Users\guthrie\Desktop> cabal install sym Resolving
> > dependencies...
> > Build profile: -w ghc-8.10.2 -O1
> > In order, the following will be built (use -v for more details):
> > - base-orphans-0.8.6 (lib) (requires download & build)
> > - primitive-0.7.3.0 (lib) (requires download & build)
> > - hashable-1.4.0.1 (lib) (requires download & build)
> > - vector-0.12.3.1 (lib) (requires download & build)
> > - sym-0.13.0 (lib) (requires download & build) Downloading
> > base-orphans-0.8.6
> > Downloaded   base-orphans-0.8.6
> > Downloading  primitive-0.7.3.0
> > Starting     base-orphans-0.8.6 (lib)
> > Downloaded   primitive-0.7.3.0
> > Downloading  vector-0.12.3.1
> > Starting     primitive-0.7.3.0 (lib)
> > Downloaded   vector-0.12.3.1
> > Downloading  hashable-1.4.0.1
> > Downloaded   hashable-1.4.0.1
> > Downloading  sym-0.13.0
> > Downloaded   sym-0.13.0
> > Building     base-orphans-0.8.6 (lib)
> > Building     primitive-0.7.3.0 (lib)
> > Installing   base-orphans-0.8.6 (lib)
> > Completed    base-orphans-0.8.6 (lib)
> > Starting     hashable-1.4.0.1 (lib)
> > Building     hashable-1.4.0.1 (lib)
> > Installing   primitive-0.7.3.0 (lib)
> > Completed    primitive-0.7.3.0 (lib)
> > Starting     vector-0.12.3.1 (lib)
> > Installing   hashable-1.4.0.1 (lib)
> > Building     vector-0.12.3.1 (lib)
> > Completed    hashable-1.4.0.1 (lib)
> > Installing   vector-0.12.3.1 (lib)
> > Completed    vector-0.12.3.1 (lib)
> > Starting     sym-0.13.0 (lib)
> > Building     sym-0.13.0 (lib)
> >
> > Failed to build sym-0.13.0.
> > Build log (
> > C:\Users\guthrie\AppData\Roaming\cabal\logs\ghc-8.10.2\sym-0.13.0-6a5a
> > 01f540d09f303c049bc421a706632878562d.log
> > ):
> > Preprocessing library for sym-0.13.0..
> > Building library for sym-0.13.0..
> >
> > Sym\Perm\STAT.hs:13:8: error:
> >     File name does not match module name:
> >     Saw: `Sym.Perm.Stat'
> >     Expected: `Sym.Perm.STAT'
> >    |
> > 13 | module Sym.Perm.Stat
> >    |        ^^^^^^^^^^^^^
> > cabal.exe: Failed to build sym-0.13.0. See the build log above for details.
> >
> > Dr. Gregory Guthrie
> >
>
> > _______________________________________________
> > Haskell-Cafe mailing list
> > To (un)subscribe, modify options or view archives go to:
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> > Only members subscribed via the mailman list are allowed to post.
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.



-- 
brandon s allbery kf8nh
allbery.b at gmail.com

From guthrie at miu.edu  Wed Dec 15 18:33:23 2021
From: guthrie at miu.edu (Gregory Guthrie)
Date: Wed, 15 Dec 2021 18:33:23 +0000
Subject: [Haskell-cafe] Error message??
Message-ID: <CH2PR03MB5224084FFCF13A4C9AA01032A1769@CH2PR03MB5224.namprd03.prod.outlook.com>

I don't understand the error here:

-- ------------------------------------------
--  Find permutation by index
iPerm :: Int -> [a] -> (Int,Int)
iPerm k list = nPerm k $ length list
   where nPerm k n = divMod k (fact(n - 1))

-- indexPerm :: Int -> [a] -> [a]
indexPerm _ [] = []
indexPerm g list = d :: indexPerm r (delete d list)     -- line 19 ***
   where (q,r) = iPerm g list
         d = list !! q

Adding a type signature for indexPerm changes the error (below),
but seems to be the same basic issue.

I thought I might need:
    indexPerm :: Eq a => Int -> [a] -> [a]
to match the restriction on delete argument types, although I would have thought that would be inferred if needed,
  but it gives the same error message.
-----------------------------------------------------------------------
Prelude> (compiling)
[1 of 1] Compiling Main             ( syntaxtest.hs, interpreted )

yntaxtest.hs:19:20: error:
    * Couldn't match expected type `indexPerm r (delete1 d1 list1)'
                  with actual type `a'
        because type variables `indexPerm', `r', `delete1', `d1', `list1'
        would escape their scope
      These (rigid, skolem) type variables are bound by
        an expression type signature:
          forall (indexPerm :: * -> * -> *) r (delete1 :: * -> * -> *) d1 list1.
          indexPerm r (delete1 d1 list1)
        at syntaxtest.hs:19:25-51
    * In the expression: d :: indexPerm r (delete d list)
      In an equation for `indexPerm':
          indexPerm g list
            = d :: indexPerm r (delete d list)
            where
                (q, r) = iPerm g list
                d = list !! q
    * Relevant bindings include
        d :: a (bound at syntaxtest.hs:21:10)
        list :: [a] (bound at syntaxtest.hs:19:13)
       indexPerm :: Int -> [a] -> [delete d list]
          (bound at syntaxtest.hs:18:1)
   |
19 | indexPerm g list = d :: indexPerm r (delete d list)

   |                    ^

   |
19 | indexPerm g list = d :: indexPerm r (delete d list)

   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Failed, no modules loaded.
-----------------------------------------------------------------------
(error with the explicit type signature)

syntaxtest.hs:19:20: error:
    * Couldn't match expected type `indexPerm r (delete d list)'
                  with actual type `a'
      `a' is a rigid type variable bound by
        the type signature for:
          indexPerm :: forall a. Int -> [a] -> [a]
        at syntaxtest.hs:17:1-30
    * In the expression: d :: indexPerm r (delete d list)
      In an equation for `indexPerm':
          indexPerm g list
            = d :: indexPerm r (delete d list)
            where
                (q, r) = iPerm g list
                d = list !! q
    * Relevant bindings include
        d :: a (bound at syntaxtest.hs:21:10)
        list :: [a] (bound at syntaxtest.hs:19:13)
        indexPerm :: Int -> [a] -> [a] (bound at syntaxtest.hs:18:1)
   |
19 | indexPerm g list = d :: indexPerm r (delete d list)

   |                    ^

   |
19 | indexPerm g list = d :: indexPerm r (delete d list)

   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Failed, no modules loaded.


Gregory Guthrie


From trebla at vex.net  Wed Dec 15 18:45:28 2021
From: trebla at vex.net (Albert Y. C. Lai)
Date: Wed, 15 Dec 2021 13:45:28 -0500
Subject: [Haskell-cafe] Error message??
In-Reply-To: <CH2PR03MB5224084FFCF13A4C9AA01032A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
References: <CH2PR03MB5224084FFCF13A4C9AA01032A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
Message-ID: <1b3b6acc-decd-4c3c-db57-52d4fe1fbd5e@vex.net>

On 2021-12-15 1:33 p.m., Gregory Guthrie wrote:
> indexPerm g list = d :: indexPerm r (delete d list)     -- line 19 ***

Double colons :: vs single colon :

From allbery.b at gmail.com  Wed Dec 15 18:50:05 2021
From: allbery.b at gmail.com (Brandon Allbery)
Date: Wed, 15 Dec 2021 13:50:05 -0500
Subject: [Haskell-cafe] Error message??
In-Reply-To: <CH2PR03MB5224084FFCF13A4C9AA01032A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
References: <CH2PR03MB5224084FFCF13A4C9AA01032A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
Message-ID: <CAKFCL4WcHnzGGA-Zre4-EsXC6dp10HaHYMU72dQT0aaO3GnHMg@mail.gmail.com>

Did you perhaps confuse Haskell with a similar language (perhaps
Agda)? :: is a type ascription, while it looks like you might have
meant list construction (:).

On Wed, Dec 15, 2021 at 1:38 PM Gregory Guthrie <guthrie at miu.edu> wrote:
>
> I don't understand the error here:
>
> -- ------------------------------------------
> --  Find permutation by index
> iPerm :: Int -> [a] -> (Int,Int)
> iPerm k list = nPerm k $ length list
>    where nPerm k n = divMod k (fact(n - 1))
>
> -- indexPerm :: Int -> [a] -> [a]
> indexPerm _ [] = []
> indexPerm g list = d :: indexPerm r (delete d list)     -- line 19 ***
>    where (q,r) = iPerm g list
>          d = list !! q
>
> Adding a type signature for indexPerm changes the error (below),
> but seems to be the same basic issue.
>
> I thought I might need:
>     indexPerm :: Eq a => Int -> [a] -> [a]
> to match the restriction on delete argument types, although I would have thought that would be inferred if needed,
>   but it gives the same error message.
> -----------------------------------------------------------------------
> Prelude> (compiling)
> [1 of 1] Compiling Main             ( syntaxtest.hs, interpreted )
>
> yntaxtest.hs:19:20: error:
>     * Couldn't match expected type `indexPerm r (delete1 d1 list1)'
>                   with actual type `a'
>         because type variables `indexPerm', `r', `delete1', `d1', `list1'
>         would escape their scope
>       These (rigid, skolem) type variables are bound by
>         an expression type signature:
>           forall (indexPerm :: * -> * -> *) r (delete1 :: * -> * -> *) d1 list1.
>           indexPerm r (delete1 d1 list1)
>         at syntaxtest.hs:19:25-51
>     * In the expression: d :: indexPerm r (delete d list)
>       In an equation for `indexPerm':
>           indexPerm g list
>             = d :: indexPerm r (delete d list)
>             where
>                 (q, r) = iPerm g list
>                 d = list !! q
>     * Relevant bindings include
>         d :: a (bound at syntaxtest.hs:21:10)
>         list :: [a] (bound at syntaxtest.hs:19:13)
>        indexPerm :: Int -> [a] -> [delete d list]
>           (bound at syntaxtest.hs:18:1)
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^
>
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> Failed, no modules loaded.
> -----------------------------------------------------------------------
> (error with the explicit type signature)
>
> syntaxtest.hs:19:20: error:
>     * Couldn't match expected type `indexPerm r (delete d list)'
>                   with actual type `a'
>       `a' is a rigid type variable bound by
>         the type signature for:
>           indexPerm :: forall a. Int -> [a] -> [a]
>         at syntaxtest.hs:17:1-30
>     * In the expression: d :: indexPerm r (delete d list)
>       In an equation for `indexPerm':
>           indexPerm g list
>             = d :: indexPerm r (delete d list)
>             where
>                 (q, r) = iPerm g list
>                 d = list !! q
>     * Relevant bindings include
>         d :: a (bound at syntaxtest.hs:21:10)
>         list :: [a] (bound at syntaxtest.hs:19:13)
>         indexPerm :: Int -> [a] -> [a] (bound at syntaxtest.hs:18:1)
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^
>
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> Failed, no modules loaded.
>
>
> Gregory Guthrie
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.



-- 
brandon s allbery kf8nh
allbery.b at gmail.com

From guthrie at miu.edu  Wed Dec 15 18:56:22 2021
From: guthrie at miu.edu (Gregory Guthrie)
Date: Wed, 15 Dec 2021 18:56:22 +0000
Subject: [Haskell-cafe] Error message??
In-Reply-To: <CAKFCL4WcHnzGGA-Zre4-EsXC6dp10HaHYMU72dQT0aaO3GnHMg@mail.gmail.com>
References: <CH2PR03MB5224084FFCF13A4C9AA01032A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <CAKFCL4WcHnzGGA-Zre4-EsXC6dp10HaHYMU72dQT0aaO3GnHMg@mail.gmail.com>
Message-ID: <CH2PR03MB5224B69737AD2E00F60D4BB8A1769@CH2PR03MB5224.namprd03.prod.outlook.com>

OMG, yes - so silly,
Thanks!

-----Original Message-----
From: Brandon Allbery <allbery.b at gmail.com> 
Sent: Wednesday, December 15, 2021 12:50 PM
To: Gregory Guthrie <guthrie at miu.edu>
Cc: haskell-cafe at haskell.org
Subject: Re: [Haskell-cafe] Error message??

Did you perhaps confuse Haskell with a similar language (perhaps Agda)? :: is a type ascription, while it looks like you might have meant list construction (:).

On Wed, Dec 15, 2021 at 1:38 PM Gregory Guthrie <guthrie at miu.edu> wrote:
>
> I don't understand the error here:
>
> -- ------------------------------------------
> --  Find permutation by index
> iPerm :: Int -> [a] -> (Int,Int)
> iPerm k list = nPerm k $ length list
>    where nPerm k n = divMod k (fact(n - 1))
>
> -- indexPerm :: Int -> [a] -> [a]
> indexPerm _ [] = []
> indexPerm g list = d :: indexPerm r (delete d list)     -- line 19 ***
>    where (q,r) = iPerm g list
>          d = list !! q
>
> Adding a type signature for indexPerm changes the error (below), but 
> seems to be the same basic issue.
>
> I thought I might need:
>     indexPerm :: Eq a => Int -> [a] -> [a] to match the restriction on 
> delete argument types, although I would have thought that would be inferred if needed,
>   but it gives the same error message.
> ----------------------------------------------------------------------
> -
> Prelude> (compiling)
> [1 of 1] Compiling Main             ( syntaxtest.hs, interpreted )
>
> yntaxtest.hs:19:20: error:
>     * Couldn't match expected type `indexPerm r (delete1 d1 list1)'
>                   with actual type `a'
>         because type variables `indexPerm', `r', `delete1', `d1', `list1'
>         would escape their scope
>       These (rigid, skolem) type variables are bound by
>         an expression type signature:
>           forall (indexPerm :: * -> * -> *) r (delete1 :: * -> * -> *) d1 list1.
>           indexPerm r (delete1 d1 list1)
>         at syntaxtest.hs:19:25-51
>     * In the expression: d :: indexPerm r (delete d list)
>       In an equation for `indexPerm':
>           indexPerm g list
>             = d :: indexPerm r (delete d list)
>             where
>                 (q, r) = iPerm g list
>                 d = list !! q
>     * Relevant bindings include
>         d :: a (bound at syntaxtest.hs:21:10)
>         list :: [a] (bound at syntaxtest.hs:19:13)
>        indexPerm :: Int -> [a] -> [delete d list]
>           (bound at syntaxtest.hs:18:1)
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^
>
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> Failed, no modules loaded.
> ----------------------------------------------------------------------
> - (error with the explicit type signature)
>
> syntaxtest.hs:19:20: error:
>     * Couldn't match expected type `indexPerm r (delete d list)'
>                   with actual type `a'
>       `a' is a rigid type variable bound by
>         the type signature for:
>           indexPerm :: forall a. Int -> [a] -> [a]
>         at syntaxtest.hs:17:1-30
>     * In the expression: d :: indexPerm r (delete d list)
>       In an equation for `indexPerm':
>           indexPerm g list
>             = d :: indexPerm r (delete d list)
>             where
>                 (q, r) = iPerm g list
>                 d = list !! q
>     * Relevant bindings include
>         d :: a (bound at syntaxtest.hs:21:10)
>         list :: [a] (bound at syntaxtest.hs:19:13)
>         indexPerm :: Int -> [a] -> [a] (bound at syntaxtest.hs:18:1)
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^
>
>    |
> 19 | indexPerm g list = d :: indexPerm r (delete d list)
>
>    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> Failed, no modules loaded.
>
>
> Gregory Guthrie
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.



--
brandon s allbery kf8nh
allbery.b at gmail.com

From guthrie at miu.edu  Wed Dec 15 18:58:25 2021
From: guthrie at miu.edu (Gregory Guthrie)
Date: Wed, 15 Dec 2021 18:58:25 +0000
Subject: [Haskell-cafe] install error: sym
In-Reply-To: <CAKFCL4VtnfxbdLv_J4E4fqYQGAvwj-SfUcAZ388af8o6TRa9Ww@mail.gmail.com>
References: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <20211215175655.GE14501@cloudinit-builder>
 <CH2PR03MB522454375151DB58A35448F5A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <CAKFCL4VtnfxbdLv_J4E4fqYQGAvwj-SfUcAZ388af8o6TRa9Ww@mail.gmail.com>
Message-ID: <CH2PR03MB522459CEAABFDE5389BE2F33A1769@CH2PR03MB5224.namprd03.prod.outlook.com>

Thanks,
Makes sense - but still fails!


-----Original Message-----
From: Brandon Allbery <allbery.b at gmail.com> 
Sent: Wednesday, December 15, 2021 12:12 PM
To: Gregory Guthrie <guthrie at miu.edu>
Cc: Tom Ellis <tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk>; haskell-cafe at haskell.org
Subject: Re: [Haskell-cafe] install error: sym

The installer probably overwrites one with the other, since the filesystem doesn't know the two are supposed to be different.

On Wed, Dec 15, 2021 at 1:11 PM Gregory Guthrie <guthrie at miu.edu> wrote:
>
> Thank you - seems right; but the installer seems to only try one variant. So any solution for Windows?
> :-)
>
>
> -----Original Message-----
> From: Haskell-Cafe <haskell-cafe-bounces at haskell.org> On Behalf Of Tom 
> Ellis
> Sent: Wednesday, December 15, 2021 11:57 AM
> To: haskell-cafe at haskell.org
> Subject: Re: [Haskell-cafe] install error: sym
>
> Perhaps this is a Windows-filesystem-case-insensitive issue.  That package has both `Stat` and `STAT`:
>
> https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-Stat.html
>
> https://hackage.haskell.org/package/sym-0.13.0/docs/Sym-Perm-STAT.html
>
> Tom
>
>
> On Wed, Dec 15, 2021 at 05:33:24PM +0000, Gregory Guthrie wrote:
> > Seems like this is a package error?
> >   Sym\Perm\STAT.hs:13:8: error:
> >     File name does not match module name:
> >     Saw: `Sym.Perm.Stat'
> >     Expected: `Sym.Perm.STAT'
> >
> >
> > Install log:
> > PS C:\Users\guthrie\Desktop> cabal install sym Resolving 
> > dependencies...
> > Build profile: -w ghc-8.10.2 -O1
> > In order, the following will be built (use -v for more details):
> > - base-orphans-0.8.6 (lib) (requires download & build)
> > - primitive-0.7.3.0 (lib) (requires download & build)
> > - hashable-1.4.0.1 (lib) (requires download & build)
> > - vector-0.12.3.1 (lib) (requires download & build)
> > - sym-0.13.0 (lib) (requires download & build) Downloading
> > base-orphans-0.8.6
> > Downloaded   base-orphans-0.8.6
> > Downloading  primitive-0.7.3.0
> > Starting     base-orphans-0.8.6 (lib)
> > Downloaded   primitive-0.7.3.0
> > Downloading  vector-0.12.3.1
> > Starting     primitive-0.7.3.0 (lib)
> > Downloaded   vector-0.12.3.1
> > Downloading  hashable-1.4.0.1
> > Downloaded   hashable-1.4.0.1
> > Downloading  sym-0.13.0
> > Downloaded   sym-0.13.0
> > Building     base-orphans-0.8.6 (lib)
> > Building     primitive-0.7.3.0 (lib)
> > Installing   base-orphans-0.8.6 (lib)
> > Completed    base-orphans-0.8.6 (lib)
> > Starting     hashable-1.4.0.1 (lib)
> > Building     hashable-1.4.0.1 (lib)
> > Installing   primitive-0.7.3.0 (lib)
> > Completed    primitive-0.7.3.0 (lib)
> > Starting     vector-0.12.3.1 (lib)
> > Installing   hashable-1.4.0.1 (lib)
> > Building     vector-0.12.3.1 (lib)
> > Completed    hashable-1.4.0.1 (lib)
> > Installing   vector-0.12.3.1 (lib)
> > Completed    vector-0.12.3.1 (lib)
> > Starting     sym-0.13.0 (lib)
> > Building     sym-0.13.0 (lib)
> >
> > Failed to build sym-0.13.0.
> > Build log (
> > C:\Users\guthrie\AppData\Roaming\cabal\logs\ghc-8.10.2\sym-0.13.0-6a
> > 5a 01f540d09f303c049bc421a706632878562d.log
> > ):
> > Preprocessing library for sym-0.13.0..
> > Building library for sym-0.13.0..
> >
> > Sym\Perm\STAT.hs:13:8: error:
> >     File name does not match module name:
> >     Saw: `Sym.Perm.Stat'
> >     Expected: `Sym.Perm.STAT'
> >    |
> > 13 | module Sym.Perm.Stat
> >    |        ^^^^^^^^^^^^^
> > cabal.exe: Failed to build sym-0.13.0. See the build log above for details.
> >
> > Dr. Gregory Guthrie
> >
>
> > _______________________________________________
> > Haskell-Cafe mailing list
> > To (un)subscribe, modify options or view archives go to:
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> > Only members subscribed via the mailman list are allowed to post.
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.



--
brandon s allbery kf8nh
allbery.b at gmail.com

From lemming at henning-thielemann.de  Wed Dec 15 19:14:37 2021
From: lemming at henning-thielemann.de (Henning Thielemann)
Date: Wed, 15 Dec 2021 20:14:37 +0100 (CET)
Subject: [Haskell-cafe] install error: sym
In-Reply-To: <CH2PR03MB522459CEAABFDE5389BE2F33A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
References: <CH2PR03MB5224F9DCC5ECA78047D11F57A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <20211215175655.GE14501@cloudinit-builder>
 <CH2PR03MB522454375151DB58A35448F5A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
 <CAKFCL4VtnfxbdLv_J4E4fqYQGAvwj-SfUcAZ388af8o6TRa9Ww@mail.gmail.com>
 <CH2PR03MB522459CEAABFDE5389BE2F33A1769@CH2PR03MB5224.namprd03.prod.outlook.com>
Message-ID: <417ec7aa-43a6-8725-96-9a8f6e76d3f@henning-thielemann.de>


On Wed, 15 Dec 2021, Gregory Guthrie wrote:

> Thanks,
> Makes sense - but still fails!

I am afraid the problem can only be solved by modifying the 'sym' package.

From gershomb at gmail.com  Wed Dec 15 19:37:30 2021
From: gershomb at gmail.com (Gershom B)
Date: Wed, 15 Dec 2021 14:37:30 -0500
Subject: [Haskell-cafe] Package takeover request for oath
In-Reply-To: <CAATCwUmOOpHvthiJcNWWzEeM4N_GTz_-iddZXP7d9ohH3U-bAQ@mail.gmail.com>
References: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
 <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>
 <a16caa84-228f-3b25-d304-43f3107eaac0@glitchbra.in>
 <CAATCwU=MGkR4XEHB+Jy2K7X+QCCkv81-XV=qcFN0m8C0USecUQ@mail.gmail.com>
 <CAATCwUmOOpHvthiJcNWWzEeM4N_GTz_-iddZXP7d9ohH3U-bAQ@mail.gmail.com>
Message-ID: <CAM8RHpEwROSKdcF95_uzeBjgCdk6wUAUng9dxf71AmTO2so8bw@mail.gmail.com>

As per the takeover procedures
(https://wiki.haskell.org/Taking_over_a_package), there's a 2-6 week
period typical. We're still at under 10 days here afaik?

--G

On Wed, Dec 15, 2021 at 1:39 AM Fumiaki Kinoshita <fumiexcel at gmail.com> wrote:
>
> Sorry to bother you again. Any thoughts?
>
> 2021年12月8日(水) 10:45 Fumiaki Kinoshita <fumiexcel at gmail.com>:
>>
>> OK. Hackage admin, could you either remove the release candidate for oath, or add me to the list of maintainers?
>>
>> 2021年12月6日(月) 17:19 Hécate <hecate at glitchbra.in>:
>>>
>>> Hi Fumiaki,
>>>
>>> hvr seems to have disengaged from his responsibilities around last year or so.
>>>
>>> Le 06/12/2021 à 08:00, Fumiaki Kinoshita a écrit :
>>>
>>> CC'd Gershom as the system failed to deliver this mail via hackage-admin.
>>>
>>> Has anyone heard from hvr? I haven't seen him in a while, either on GitHub or ML
>>>
>>> 2021年12月5日(日) 11:25 Fumiaki Kinoshita <fumiexcel at gmail.com>:
>>>>
>>>> At the moment, oath is registered as a "reserved package name" (see https://mail.haskell.org/pipermail/libraries/2021-December/031524.html) and does not exist as an actual package.
>>>>
>>>> I'd like to upload a package with this name unless there's a specific reason why I should not.
>>>> My Hackage username is FumiakiKinoshita.
>>>>
>>>> Best regards,
>>>
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> To (un)subscribe, modify options or view archives go to:
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>>> Only members subscribed via the mailman list are allowed to post.
>>>
>>> --
>>> Hécate ✨
>>> 🐦: @TechnoEmpress
>>> IRC: Hecate
>>> WWW: https://glitchbra.in
>>> RUN: BSD
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> To (un)subscribe, modify options or view archives go to:
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>>> Only members subscribed via the mailman list are allowed to post.

From gershomb at gmail.com  Fri Dec 17 20:07:11 2021
From: gershomb at gmail.com (Gershom B)
Date: Fri, 17 Dec 2021 15:07:11 -0500
Subject: [Haskell-cafe] Package takeover request for oath
In-Reply-To: <CAM8RHpEwROSKdcF95_uzeBjgCdk6wUAUng9dxf71AmTO2so8bw@mail.gmail.com>
References: <CAATCwU=Rm0ciB0ELqqSJWu8YVtWd3VWCUnki+402KK4Sd1B_LA@mail.gmail.com>
 <CAATCwUk34KFxdS7cjtZpPT3OTXAfedcWCUAd9J=67sfLmRoNLQ@mail.gmail.com>
 <a16caa84-228f-3b25-d304-43f3107eaac0@glitchbra.in>
 <CAATCwU=MGkR4XEHB+Jy2K7X+QCCkv81-XV=qcFN0m8C0USecUQ@mail.gmail.com>
 <CAATCwUmOOpHvthiJcNWWzEeM4N_GTz_-iddZXP7d9ohH3U-bAQ@mail.gmail.com>
 <CAM8RHpEwROSKdcF95_uzeBjgCdk6wUAUng9dxf71AmTO2so8bw@mail.gmail.com>
Message-ID: <CAM8RHpG=k8zSstHiviLnVD26Dtb5Y3126qoA1SyxShjX5vsSew@mail.gmail.com>

I reached herbert and he confirmed he's ok with this, so I've added
you to the maintainers group.

-gershom

On Wed, Dec 15, 2021 at 2:37 PM Gershom B <gershomb at gmail.com> wrote:
>
> As per the takeover procedures
> (https://wiki.haskell.org/Taking_over_a_package), there's a 2-6 week
> period typical. We're still at under 10 days here afaik?
>
> --G
>
> On Wed, Dec 15, 2021 at 1:39 AM Fumiaki Kinoshita <fumiexcel at gmail.com> wrote:
> >
> > Sorry to bother you again. Any thoughts?
> >
> > 2021年12月8日(水) 10:45 Fumiaki Kinoshita <fumiexcel at gmail.com>:
> >>
> >> OK. Hackage admin, could you either remove the release candidate for oath, or add me to the list of maintainers?
> >>
> >> 2021年12月6日(月) 17:19 Hécate <hecate at glitchbra.in>:
> >>>
> >>> Hi Fumiaki,
> >>>
> >>> hvr seems to have disengaged from his responsibilities around last year or so.
> >>>
> >>> Le 06/12/2021 à 08:00, Fumiaki Kinoshita a écrit :
> >>>
> >>> CC'd Gershom as the system failed to deliver this mail via hackage-admin.
> >>>
> >>> Has anyone heard from hvr? I haven't seen him in a while, either on GitHub or ML
> >>>
> >>> 2021年12月5日(日) 11:25 Fumiaki Kinoshita <fumiexcel at gmail.com>:
> >>>>
> >>>> At the moment, oath is registered as a "reserved package name" (see https://mail.haskell.org/pipermail/libraries/2021-December/031524.html) and does not exist as an actual package.
> >>>>
> >>>> I'd like to upload a package with this name unless there's a specific reason why I should not.
> >>>> My Hackage username is FumiakiKinoshita.
> >>>>
> >>>> Best regards,
> >>>
> >>>
> >>> _______________________________________________
> >>> Haskell-Cafe mailing list
> >>> To (un)subscribe, modify options or view archives go to:
> >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> >>> Only members subscribed via the mailman list are allowed to post.
> >>>
> >>> --
> >>> Hécate ✨
> >>> 🐦: @TechnoEmpress
> >>> IRC: Hecate
> >>> WWW: https://glitchbra.in
> >>> RUN: BSD
> >>>
> >>> _______________________________________________
> >>> Haskell-Cafe mailing list
> >>> To (un)subscribe, modify options or view archives go to:
> >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> >>> Only members subscribed via the mailman list are allowed to post.

From P.Achten at cs.ru.nl  Mon Dec 20 15:25:44 2021
From: P.Achten at cs.ru.nl (Peter Achten)
Date: Mon, 20 Dec 2021 16:25:44 +0100
Subject: [Haskell-cafe] 3 Fully funded PhD positions in Software Technology
 at Radboud University, Netherlands
Message-ID: <7610b852-5015-c762-c4f5-0680a2a92bf1@cs.ru.nl>

--------------------------------------------------------------------------------------
3 Fully funded PhD positions in Software Technology at Radboud 
University, Netherlands
--------------------------------------------------------------------------------------

In the Software Technology group at Radboud University in Nijmegen, 
Netherlands, we are
looking for enthusiastic and outstanding Computer Science or Mathematics 
students with
a strong background in at least one of the following areas:
  * programming languages
  * compiler technology
  * code generation
  * runtime systems
  * High-Performance-Computing
  * Parallel Computing
to strengthen our group.

Our key driving force is the desire to combine programming language 
research with compiler
technology and code generation techniques for creating practically 
applicable software
tools. Our credo lies in HP3 technology: combining High-Productivity, 
High-Portability,
and High-Performance.

Long-term projects driven by our group include the Clean project 
(clean.cs.ru.nl), the SaC
project (www.sac-home.org), and the iTask system (clean.cs.ru.nl/ITasks).

Our current focal points are: *Gradual Programming*, *Swarm Computing*, 
*Heterogeneous High-
Performance Computing*, *Sustainable and Energy-Efficient Computing*.

With *Gradual Programming*, we aim to combine the flexibility of rapid 
prototyping with the
type safety of strongly typed programming languages. We look into a 
radically new approach
towards typing programming languages for increased productivity, 
correctness and
sustainability.
Please contact Peter Achten (P.Achten at cs.ru.nl) for details.

*Swarm Computing* refers to the idea of being able to, from a single 
source, perform
programming, controlling, and computation on a dynamic and hybrid 
collection of computational
units varying from CPUs, GPUs, FPGAs, TPUs, to IoT devices. Currently, 
we are particularly
interested in Swarm Computing for sustainable IoT utilisation.
Please contact Pieter Koopman (pieter at cs.ru.nl) for details.

In *Heterogeneous High-Performance Computing*, we are interested in the 
generation of code
for swarm computing systems aiming for unprecedented levels of 
efficiency in terms of both,
runtime and energy efficiency. This includes mainstream accelerators 
such as GPUs and FPGAs
as well as novel architectures such as Cerebras’ new architecture 
(www.cerebras.net). This
work will contribute to the new TEN-X initiative (mission10-x.org).
Please contact Sven-Bodo Scholz (SvenBodo.Scholz at ru.nl) for details.

We offer:
  * a gross monthly salary starting from €2,434 in the first year, 
step-wise increasing to
    €3,111 in the fourth year.
  * a 4 year full-time contract, subject to a successful performance 
evaluation after 18 months.
  * a stimulating work environment with excellent Dual Career and Family 
Care Services.

= How to apply =
Applications should consist of a single pdf-file containing your CV, a 
cover letter explaining
your motivation, and a letter of reference. We will consider 
applications as they arrive until
the positions are filled. The deadline for applications is January 31 2022.

Please send your application to: SvenBodo.Scholz at ru.nl.


From shashankmobispc at gmail.com  Fri Dec 24 01:15:39 2021
From: shashankmobispc at gmail.com (Shashank Swarup)
Date: Thu, 23 Dec 2021 21:15:39 -0400
Subject: [Haskell-cafe] CFP (Deadline Extended): The 5th International
 Conference on Emerging Data and Industry 4.0 (EDI40) Porto,
 Portugal March 22-25, 2022
Message-ID: <CAE4dgq9ZRzY_8DjOTWf6+dLX_+4LR_PTxcUj52v6Ud82b6MWFA@mail.gmail.com>

***************************************************************************
The 5th International Conference on Emerging Data and Industry 4.0 (EDI40)
Porto, Portugal
March 22-25, 2022
***************************************************************************

Conference Website:  http://cs-conferences.acadiau.ca/EDI40-22/
Workshops: http://cs-conferences.acadiau.ca/EDI40-22/#workshop

Important Dates
  - Workshops Proposals Due: October 1, 2021

*   - Paper Submission Due: December 30, 2021 (Revised & Firm)*   -
Acceptance Notification: January 15, 2022
   - Camera-Ready Submission: February 10, 2022


EDI40 2022 accepted papers will be published by Elsevier Science in the
open-access Procedia Computer Science series on-line. Procedia Computer
Science is hosted by Elsevier on www.Elsevier.com and on Elsevier content
platform ScienceDirect (www.sciencedirect.com), and will be freely
available worldwide. All papers in Procedia will be indexed by Scopus (
www.scopus.com) and by Thomson Reuters' Conference Proceeding Citation
Index (http://thomsonreuters.com/conference-proceedings-citation-index/).
All papers in Procedia will also be indexed by Scopus (www.scopus.com) and
Engineering Village (Ei) (www.engineeringvillage.com). This includes EI
Compendex (www.ei.org/compendex). Moreover, all accepted papers will be
indexed in DBLP (http://dblp.uni-trier.de/). The papers will contain linked
references, XML versions and citable DOI numbers. You will be able to
provide a hyperlink to all delegates and direct your conference website
visitors to your proceedings. Selected papers will be invited for
publication, in the special issues of:

 - International Journal of Ambient Intelligence and Humanized Computing
(IF: 4.594), by Springer (http://www.springer.com/engineering/journal/12652)
- International Journal Personal and Ubiquitous Computing (IF:3.006),
Springer (https://www.springer.com/journal/779)
- International Journal on Transportation Research Part A: Policy and
Practice (IF: 3.992), by Elsevier (
https://www.journals.elsevier.com/transportation-research-part-a-policy-and-practice/
)
- International Journal of Computing and Informatics (IF: 0.524), by
Computing and Informatics (http://www.cai.sk/ojs/index.php/cai/index)


EDI40 2022 will be held in Porto, Portugal. Porto is the second-largest
city in Portugal after Lisbon and one of the major urban areas of the
Iberian Peninsula. Porto is also called the Invicta because during the 19th
century Portuguese civil war, the city withstood a siege of over a year.The
urban area of Porto, which extends beyond the administrative limits of the
city, has a population of 2.1 million in an area of 389 km2 (150 sq mi),
making it the second-largest urban area in Portugal. It is recognized as a
gamma- level global city by the Globalization and World Cities (GaWC) Study
Group, the only Portuguese city besides Lisbon to be recognized as a global
city.
EDI40 will be held in conjunction with the 13th International Conference on
Ambient Systems, Networks and Technologies (ANT 2022).

Conference Tracks
  - Benefits of Industry 4.0
  - Big Data and Analytics
  - Cloud Computing
  - Cognitive Computing
  - Computational Intelligence
  - Cyber-Physical Systems (CPS)
  - Fog Computing and Edge Computing
  - Internet of Everything (IoE)
  - Standards for IoT Application Integration
  - The New Business Models in Industry 4.0
  - General Track: Digitalization Startegies

Committees
General Chair
  Danny Hughes, CTO VeraSense NV, Belgium

Program Chairs
  Jamal Bentahar, Concordia University, Canada
  Haroon Malik, Marshall University, USA

Local Chair
  Nuno Varandas, F6S (Where Founders Grow Together), Portugal

Workshops Chair
  Stephane Galland, UTBM, France Program

Advisory Committee
  Reda Alhajj, University of Calgary, Canada
  Ladislav Hluchy, Institute of Informatics, Slovak Academy of Sciences,
Slovakia
  Vincenzo Loia, University of Salerno, Italy
  Peter Sloot, Universiteit van Amsterdam, Netherlands
  Peter Thomas, Manifesto Research, Australia
  Mohamed Younis, University of Maryland Baltimore County, USA

International Journals Chair
  Michael Sheng, Macquarie University, Australia

Publicity Chairs
  Wim Ectors, Hasselt University, Belgium
  Faouzi Kammoun, Ecole Supérieure Privée d'Ingénierie et de
Technologies, Tunis
  Aneta Poniszewska-Marańda, Lodz University of Technology, Poland
  Shashank Swarup, Acadia University, Canada

Technical Program Committee
  http://cs-conferences.acadiau.ca/EDI40-22/#programCommittees

International Liaison Chairs
  Soumaya Cherkaoui, Sherbrooke University, Canada
  Nik Bessis, Edge Hill University, UK
  David Taniar, Monash University, Australia

Steering Committee Chair and Founder
  Elhadi Shakshuki, Acadia University, Canada
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211223/c0e20ab2/attachment.html>

From andrew.lelechenko at gmail.com  Fri Dec 24 19:17:30 2021
From: andrew.lelechenko at gmail.com (Andrew Lelechenko)
Date: Fri, 24 Dec 2021 19:17:30 +0000
Subject: [Haskell-cafe] text-2.0 with UTF8 is finally released!
Message-ID: <05104C77-5B72-4BC6-BBC1-6E8A01EF0D55@gmail.com>

I’m happy to announce that text-2.0 with UTF-8 underlying representation has been finally released: https://hackage.haskell.org/package/text-2.0. The release is identical to rc2, circulated earlier.

Changelog: https://hackage.haskell.org/package/text-2.0/changelog

Please give it a try. Here is a cabal.project template: https://gist.github.com/Bodigrim/9834568f075be36a1c65e7aaba6a15db

This work would not be complete without a blazingly-fast UTF-8 validator, submitted by Koz Ross into bytestring-0.11.2.0, whose contributions were sourced via HF as an in-kind donation from MLabs. I would like to thank Emily Pillmore for encouraging me to take on this project, helping with the proposal and permissions. I’m grateful to my fellow text maintainers, who’ve been carefully reviewing my work in course of the last six months, as well as helpful and responsive maintainers of downstream packages and GHC developers. Thanks all, it was a pleasant journey!

Best regards,
Andrew

From tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk  Fri Dec 24 19:24:50 2021
From: tom-lists-haskell-cafe-2017 at jaguarpaw.co.uk (Tom Ellis)
Date: Fri, 24 Dec 2021 19:24:50 +0000
Subject: [Haskell-cafe] text-2.0 with UTF8 is finally released!
In-Reply-To: <05104C77-5B72-4BC6-BBC1-6E8A01EF0D55@gmail.com>
References: <05104C77-5B72-4BC6-BBC1-6E8A01EF0D55@gmail.com>
Message-ID: <20211224192450.GD17923@cloudinit-builder>

This is great news.  Congratulations to Andrew and everyone else who
contributed!

On Fri, Dec 24, 2021 at 07:17:30PM +0000, Andrew Lelechenko wrote:
> I’m happy to announce that text-2.0 with UTF-8 underlying representation has been finally released: https://hackage.haskell.org/package/text-2.0. The release is identical to rc2, circulated earlier.
> 
> Changelog: https://hackage.haskell.org/package/text-2.0/changelog
> 
> Please give it a try. Here is a cabal.project template: https://gist.github.com/Bodigrim/9834568f075be36a1c65e7aaba6a15db
> 
> This work would not be complete without a blazingly-fast UTF-8 validator, submitted by Koz Ross into bytestring-0.11.2.0, whose contributions were sourced via HF as an in-kind donation from MLabs. I would like to thank Emily Pillmore for encouraging me to take on this project, helping with the proposal and permissions. I’m grateful to my fellow text maintainers, who’ve been carefully reviewing my work in course of the last six months, as well as helpful and responsive maintainers of downstream packages and GHC developers. Thanks all, it was a pleasant journey!

From zubin at well-typed.com  Sat Dec 25 20:20:27 2021
From: zubin at well-typed.com (Zubin Duggal)
Date: Sun, 26 Dec 2021 01:50:27 +0530
Subject: [Haskell-cafe] [Haskell] [ANNOUNCE] GHC 9.0.2 released
Message-ID: <20211225202027.jxlafyybul4bltfb@zubin-msi>

The GHC developers are very happy to at long last announce the
availability of GHC 9.0.2. Binary distributions, source distributions,
and documentation are available at the 
[usual place](https://downloads.haskell.org/ghc/9.0.2/).

Download Page: https://www.haskell.org/ghc/download_ghc_9_0_2.html
Blog Post: https://www.haskell.org/ghc/blog/20211225-ghc-9.0.2-released.html

GHC 9.0.2 adds first class AArch64/Darwin support using the LLVM
backend, as well as fixing a number of critical correctness bugs
with the 9.0.1 release, along with numerous improvements to compiler
performance and memory usage:

* First-class support for Apple M1 hardware using GHC's LLVM ARM
   backend.

* Fix a number of incorrect rewrite rules for `fromInteger` (#19345,
   #20066).

* Fix a number of runtime system and GC bugs which typically manifested
   in crashes (#19417, #19297, #19645, #19667, #18033, #20132, #19715,
   #20399, #20414, #20649, #19147, #20051, #20093)

* Fixes for various compiler performance and memory usage issues
   (#20134, #13586, #20509, #19668, #19996, #19471)

* Improvements and bug fixes for the code generator and optimiser
   (#18638, #19581, #19700, #19996, #19181, #19822)

* Fixes for typechecker bugs (#19410 , #19191, #19522, #19400, #19849)

* Bug fixes for the frontend and parser (#19397, #19838, #19518, #19777, #20242, #19786)

* Emit warnings if Unicode Bidirectional Formatting characters are found
   in the source, possibly misleading code reviewers (#20263).

* Many packaging related fixes, including versioned `ghc-pkg`
   executables (#20087), and actually distributing GHC versions linked
   against the `native` big integer backend (#18967, #19953) on both
   Windows and Alpine Linux. Some previous releases were still linked
   against the `GMP` library due to a misconfiguration of the builders.

* A significant refactoring of `process` fixing numerous bugs mostly on
   Apple platforms (#19994, [process refactoring](https://github.com/haskell/process/pull/208)).

* Bug fixes for the linker on Darwin platforms (#20004, #19968, #19950).

A complete list of bug fixes and improvements can be found in the [release
notes](https://downloads.haskell.org/ghc/9.0.2/docs/html/users_guide/9.0.2-notes.html).

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 Holidays and Happy Hacking!

- Zubin
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 488 bytes
Desc: not available
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211226/0d48912d/attachment.sig>

From shayne.fletcher.50 at gmail.com  Sat Dec 25 20:37:38 2021
From: shayne.fletcher.50 at gmail.com (Shayne Fletcher)
Date: Sat, 25 Dec 2021 15:37:38 -0500
Subject: [Haskell-cafe] [Haskell] [ANNOUNCE] GHC 9.0.2 released
In-Reply-To: <20211225202027.jxlafyybul4bltfb@zubin-msi>
References: <20211225202027.jxlafyybul4bltfb@zubin-msi>
Message-ID: <CAMsAzy9J39kq=cnTTPWzJw3rUo_WNXfSAQQx+G_ep-EWGton0w@mail.gmail.com>

Awesome. Thank-you! There appears not to be a ghc-9.0.2-release tag. Might
this be addressed please?

On Sat, Dec 25, 2021 at 3:22 PM Zubin Duggal <zubin at well-typed.com> wrote:

> The GHC developers are very happy to at long last announce the
> availability of GHC 9.0.2. Binary distributions, source distributions,
> and documentation are available at the
> [usual place](https://downloads.haskell.org/ghc/9.0.2/).
>
> Download Page: https://www.haskell.org/ghc/download_ghc_9_0_2.html
> Blog Post:
> https://www.haskell.org/ghc/blog/20211225-ghc-9.0.2-released.html
>
> GHC 9.0.2 adds first class AArch64/Darwin support using the LLVM
> backend, as well as fixing a number of critical correctness bugs
> with the 9.0.1 release, along with numerous improvements to compiler
> performance and memory usage:
>
> * First-class support for Apple M1 hardware using GHC's LLVM ARM
>    backend.
>
> * Fix a number of incorrect rewrite rules for `fromInteger` (#19345,
>    #20066).
>
> * Fix a number of runtime system and GC bugs which typically manifested
>    in crashes (#19417, #19297, #19645, #19667, #18033, #20132, #19715,
>    #20399, #20414, #20649, #19147, #20051, #20093)
>
> * Fixes for various compiler performance and memory usage issues
>    (#20134, #13586, #20509, #19668, #19996, #19471)
>
> * Improvements and bug fixes for the code generator and optimiser
>    (#18638, #19581, #19700, #19996, #19181, #19822)
>
> * Fixes for typechecker bugs (#19410 , #19191, #19522, #19400, #19849)
>
> * Bug fixes for the frontend and parser (#19397, #19838, #19518, #19777,
> #20242, #19786)
>
> * Emit warnings if Unicode Bidirectional Formatting characters are found
>    in the source, possibly misleading code reviewers (#20263).
>
> * Many packaging related fixes, including versioned `ghc-pkg`
>    executables (#20087), and actually distributing GHC versions linked
>    against the `native` big integer backend (#18967, #19953) on both
>    Windows and Alpine Linux. Some previous releases were still linked
>    against the `GMP` library due to a misconfiguration of the builders.
>
> * A significant refactoring of `process` fixing numerous bugs mostly on
>    Apple platforms (#19994, [process refactoring](
> https://github.com/haskell/process/pull/208)).
>
> * Bug fixes for the linker on Darwin platforms (#20004, #19968, #19950).
>
> A complete list of bug fixes and improvements can be found in the [release
> notes](
> https://downloads.haskell.org/ghc/9.0.2/docs/html/users_guide/9.0.2-notes.html
> ).
>
> 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 Holidays and Happy Hacking!
>
> - Zubin
> _______________________________________________
> ghc-devs mailing list
> ghc-devs at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs
>


-- 
Shayne Fletcher
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211225/9a82a094/attachment.html>

From zubin at well-typed.com  Sat Dec 25 20:42:17 2021
From: zubin at well-typed.com (Zubin Duggal)
Date: Sun, 26 Dec 2021 02:12:17 +0530
Subject: [Haskell-cafe] [Haskell] [ANNOUNCE] GHC 9.0.2 released
In-Reply-To: <CAMsAzy9J39kq=cnTTPWzJw3rUo_WNXfSAQQx+G_ep-EWGton0w@mail.gmail.com>
References: <20211225202027.jxlafyybul4bltfb@zubin-msi>
 <CAMsAzy9J39kq=cnTTPWzJw3rUo_WNXfSAQQx+G_ep-EWGton0w@mail.gmail.com>
Message-ID: <20211225204217.z76iampqlg7n3jzp@zubin-msi>

Oops. Pushed!

On 21/12/25 15:37, Shayne Fletcher wrote:
>Awesome. Thank-you! There appears not to be a ghc-9.0.2-release tag. Might
>this be addressed please?
>

From harendra.kumar at gmail.com  Sun Dec 26 07:14:41 2021
From: harendra.kumar at gmail.com (Harendra Kumar)
Date: Sun, 26 Dec 2021 12:44:41 +0530
Subject: [Haskell-cafe] text-2.0 with UTF8 is finally released!
In-Reply-To: <05104C77-5B72-4BC6-BBC1-6E8A01EF0D55@gmail.com>
References: <05104C77-5B72-4BC6-BBC1-6E8A01EF0D55@gmail.com>
Message-ID: <CAPW+kkYCP6_xuXAGPwnLaAh25L6hz83r2Z=sBZGDNB0i37dXCw@mail.gmail.com>

Amazing work. Thanks Andrew and all others involved!

On Sat, 25 Dec 2021 at 00:48, Andrew Lelechenko <andrew.lelechenko at gmail.com>
wrote:

> I’m happy to announce that text-2.0 with UTF-8 underlying representation
> has been finally released: https://hackage.haskell.org/package/text-2.0.
> The release is identical to rc2, circulated earlier.
>
> Changelog: https://hackage.haskell.org/package/text-2.0/changelog
>
> Please give it a try. Here is a cabal.project template:
> https://gist.github.com/Bodigrim/9834568f075be36a1c65e7aaba6a15db
>
> This work would not be complete without a blazingly-fast UTF-8 validator,
> submitted by Koz Ross into bytestring-0.11.2.0, whose contributions were
> sourced via HF as an in-kind donation from MLabs. I would like to thank
> Emily Pillmore for encouraging me to take on this project, helping with the
> proposal and permissions. I’m grateful to my fellow text maintainers,
> who’ve been carefully reviewing my work in course of the last six months,
> as well as helpful and responsive maintainers of downstream packages and
> GHC developers. Thanks all, it was a pleasant journey!
>
> Best regards,
> Andrew
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20211226/efb57390/attachment.html>

From sgf.dma at gmail.com  Thu Dec 30 14:50:44 2021
From: sgf.dma at gmail.com (Dmitriy Matrosov)
Date: Thu, 30 Dec 2021 17:50:44 +0300
Subject: [Haskell-cafe] Coercing existential according to type-level Maybe
	(re-post from h-beginners)
Message-ID: <CAFdVUFkZtWHwJsfdRUNnQVA1q2qej7eL4suh7AcQwDAZrxQ26Q@mail.gmail.com>

(as suggested, i'm re-asking here)

Hi.

I've tried to write a function to coerce existential value according to type
stored in type-level 'Maybe' (i.e. 'Just or 'Nothing).

> {-# LANGUAGE DataKinds #-}
> {-# LANGUAGE RankNTypes #-}
> {-# LANGUAGE KindSignatures #-}
> {-# LANGUAGE PolyKinds #-}
> {-# LANGUAGE TypeFamilies #-}
> {-# LANGUAGE GADTs #-}
>
> import Data.Kind
> import Data.Proxy
> import Unsafe.Coerce
>
> class FromTypeMaybe k where
>     type ToType k
>     fromTypeMaybe :: (a -> ToType k) -> Proxy k -> a -> Maybe (ToType k)
>
> --instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where
> instance forall (t :: Type). FromTypeMaybe ('Nothing @t) where
>     type ToType 'Nothing = t
>     fromTypeMaybe f _ x = Nothing
>
> instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe Type) where
>     type ToType ('Just t) = t
>     fromTypeMaybe f _ x = Just (f x)
>
> data Any where
>     Any :: a -> Any
>
> unAny :: Any -> t
> unAny (Any x) = unsafeCoerce x

This works as far as i can see

    *Main> fromTypeMaybe unAny (Proxy @('Just Int)) (Any 3)
    Just 3
    *Main> fromTypeMaybe unAny (Proxy @'Nothing) undefined
    Nothing

but i don't understand how 'Nothing instance works:

                   type   kind                                  kind?
                    vvv  vvvvvv                                  vvv
    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where
         type ToType 'Nothing = t
                               ^^^
                               type

(in case alignment breaks: variable 't' in forall is type-variable with kind
'Type', but in "Maybe t" in instance head it's used as kind-variable. And then
in associated type-family the same variable 't' is used as type-variable
again).

If i try to write "'Nothing"'s kind as 'Maybe Type' (in the same manner as
'Just has)

    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe Type) where

i get an error:

    1.lhs:21:3: error:
        • Type variable ‘t’ is mentioned in the RHS,
            but not bound on the LHS of the family instance
        • In the type instance declaration for ‘ToType’
          In the instance declaration for
            ‘FromTypeMaybe ('Nothing :: Maybe Type)’
       |
    21 | > instance forall (t :: Type). FromTypeMaybe ('Nothing ::
Maybe Type) where
       |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...

Well, i'm not sure, that understand why 'forall' in instance head may not be
used as family's LHS, but.. that's another question.  On the other
hand, if i try
to write 'Just instance using type-variable 't' as kind-variable (in the same
manner as 'Nothing has):

    instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where

i get an error too:

    1.lhs:25:47: error:
        • Expected kind ‘Maybe t’, but ‘'Just t’ has kind ‘Maybe *’
        • In the first argument of ‘FromTypeMaybe’, namely
            ‘('Just t :: Maybe t)’
          In the instance declaration for
            ‘FromTypeMaybe ('Just t :: Maybe t)’
       |
    25 | > instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where

Well, that's also probably expected, because though i've declared
type-variable 't' with kind 'Type' in forall, due to 'DataKinds' extension
type 't' is also promoted to kind 't' and, thus, by using ('Just t :: Maybe t)
i say, that ('Just t) should have kind 'Maybe t', not 'Maybe Type', which it
really has.

But if that's so, how working 'Nothing instance

    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where

may work at all? It has the same problem as 'Just instance above:
type-variable 't' is promoted to kind 't' and 'Nothing will have kind 'Maybe
t' instead of 'Maybe Type' ?

From lists at richarde.dev  Thu Dec 30 16:42:33 2021
From: lists at richarde.dev (Richard Eisenberg)
Date: Thu, 30 Dec 2021 16:42:33 +0000
Subject: [Haskell-cafe] Coercing existential according to type-level
 Maybe (re-post from h-beginners)
In-Reply-To: <CAFdVUFkZtWHwJsfdRUNnQVA1q2qej7eL4suh7AcQwDAZrxQ26Q@mail.gmail.com>
References: <CAFdVUFkZtWHwJsfdRUNnQVA1q2qej7eL4suh7AcQwDAZrxQ26Q@mail.gmail.com>
Message-ID: <010f017e0c38c22e-30a5eec7-850a-4f1f-af67-1ba48b123d55-000000@us-east-2.amazonses.com>

Hi Dmitriy,

Fun stuff here!

- Have you looked at https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Dynamic.html ? That may have the functionality you're looking for. It's quite a bit simpler than the construction you're building, but it might satisfy your eventual use-case.

- GHC does not distinguish between types and kinds, since GHC 8.0. Much literature about Haskell continues to make this distinction, including GHC's own error messages (at some implementation challenge, even). This is because, most of the time, programs don't cross the line between types and kinds, and this distinction can be helpful. However, your code does shuttle ideas back and forth across the line, and so the distinction is harmful. Bottom line here: treat types and kinds as synonyms. The design of Haskell does, internally.

- I think the crux of your question is why (Just t :: Maybe t) fails to type-check. We can see this in the type of Just: Just :: forall (a :: Type). a -> Maybe a. When we write `Just t` (for `t :: Type`), GHC sees `Just @Type t`, supplying the invisible instantiation for the `forall (a :: Type)` argument in Just's type. We can now see that `Just @Type t` will have type `Maybe Type`, just by substituting in Just's type. So saying `Just t :: Maybe t` will be rejected.

- On the other hand, `Nothing :: Maybe t` is fine. We have `Nothing :: forall (a :: Type). Maybe a`, and so `Nothing :: Maybe t` really means `Nothing @t :: Maybe t`, and all is well.

I worry that there is more in your email that I haven't answered here. If so, please write back!

Richard

> On Dec 30, 2021, at 9:50 AM, Dmitriy Matrosov <sgf.dma at gmail.com> wrote:
> 
> (as suggested, i'm re-asking here)
> 
> Hi.
> 
> I've tried to write a function to coerce existential value according to type
> stored in type-level 'Maybe' (i.e. 'Just or 'Nothing).
> 
>> {-# LANGUAGE DataKinds #-}
>> {-# LANGUAGE RankNTypes #-}
>> {-# LANGUAGE KindSignatures #-}
>> {-# LANGUAGE PolyKinds #-}
>> {-# LANGUAGE TypeFamilies #-}
>> {-# LANGUAGE GADTs #-}
>> 
>> import Data.Kind
>> import Data.Proxy
>> import Unsafe.Coerce
>> 
>> class FromTypeMaybe k where
>>    type ToType k
>>    fromTypeMaybe :: (a -> ToType k) -> Proxy k -> a -> Maybe (ToType k)
>> 
>> --instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where
>> instance forall (t :: Type). FromTypeMaybe ('Nothing @t) where
>>    type ToType 'Nothing = t
>>    fromTypeMaybe f _ x = Nothing
>> 
>> instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe Type) where
>>    type ToType ('Just t) = t
>>    fromTypeMaybe f _ x = Just (f x)
>> 
>> data Any where
>>    Any :: a -> Any
>> 
>> unAny :: Any -> t
>> unAny (Any x) = unsafeCoerce x
> 
> This works as far as i can see
> 
>    *Main> fromTypeMaybe unAny (Proxy @('Just Int)) (Any 3)
>    Just 3
>    *Main> fromTypeMaybe unAny (Proxy @'Nothing) undefined
>    Nothing
> 
> but i don't understand how 'Nothing instance works:
> 
>                   type   kind                                  kind?
>                    vvv  vvvvvv                                  vvv
>    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where
>         type ToType 'Nothing = t
>                               ^^^
>                               type
> 
> (in case alignment breaks: variable 't' in forall is type-variable with kind
> 'Type', but in "Maybe t" in instance head it's used as kind-variable. And then
> in associated type-family the same variable 't' is used as type-variable
> again).
> 
> If i try to write "'Nothing"'s kind as 'Maybe Type' (in the same manner as
> 'Just has)
> 
>    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe Type) where
> 
> i get an error:
> 
>    1.lhs:21:3: error:
>        • Type variable ‘t’ is mentioned in the RHS,
>            but not bound on the LHS of the family instance
>        • In the type instance declaration for ‘ToType’
>          In the instance declaration for
>            ‘FromTypeMaybe ('Nothing :: Maybe Type)’
>       |
>    21 | > instance forall (t :: Type). FromTypeMaybe ('Nothing ::
> Maybe Type) where
>       |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
> 
> Well, i'm not sure, that understand why 'forall' in instance head may not be
> used as family's LHS, but.. that's another question.  On the other
> hand, if i try
> to write 'Just instance using type-variable 't' as kind-variable (in the same
> manner as 'Nothing has):
> 
>    instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where
> 
> i get an error too:
> 
>    1.lhs:25:47: error:
>        • Expected kind ‘Maybe t’, but ‘'Just t’ has kind ‘Maybe *’
>        • In the first argument of ‘FromTypeMaybe’, namely
>            ‘('Just t :: Maybe t)’
>          In the instance declaration for
>            ‘FromTypeMaybe ('Just t :: Maybe t)’
>       |
>    25 | > instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where
> 
> Well, that's also probably expected, because though i've declared
> type-variable 't' with kind 'Type' in forall, due to 'DataKinds' extension
> type 't' is also promoted to kind 't' and, thus, by using ('Just t :: Maybe t)
> i say, that ('Just t) should have kind 'Maybe t', not 'Maybe Type', which it
> really has.
> 
> But if that's so, how working 'Nothing instance
> 
>    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where
> 
> may work at all? It has the same problem as 'Just instance above:
> type-variable 't' is promoted to kind 't' and 'Nothing will have kind 'Maybe
> t' instead of 'Maybe Type' ?
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.


From sgf.dma at gmail.com  Fri Dec 31 13:33:28 2021
From: sgf.dma at gmail.com (Dmitriy Matrosov)
Date: Fri, 31 Dec 2021 16:33:28 +0300
Subject: [Haskell-cafe] Coercing existential according to type-level
 Maybe (re-post from h-beginners)
In-Reply-To: <010f017e0c38c22e-30a5eec7-850a-4f1f-af67-1ba48b123d55-000000@us-east-2.amazonses.com>
References: <CAFdVUFkZtWHwJsfdRUNnQVA1q2qej7eL4suh7AcQwDAZrxQ26Q@mail.gmail.com>
 <010f017e0c38c22e-30a5eec7-850a-4f1f-af67-1ba48b123d55-000000@us-east-2.amazonses.com>
Message-ID: <CAFdVUFm4mSBgcULkQ7YyY-dhbmXVCnNB6umac-FCjJdhUbm=XA@mail.gmail.com>

Hi, Richard.

> - Have you looked at https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Dynamic.html ? That may have the functionality you're looking for. It's quite a bit simpler than the construction you're building, but it might satisfy your eventual use-case.

Not yet. In fact, i don't have any particular use-case, i'm just
reading "thinking with types" book and tried to experiment a little.
But anyway, i'll look at this package, thanks!

> - GHC does not distinguish between types and kinds, since GHC 8.0. Much literature about Haskell continues to make this distinction, including GHC's own error messages (at some implementation challenge, even). This is because, most of the time, programs don't cross the line between types and kinds, and this distinction can be helpful. However, your code does shuttle ideas back and forth across the line, and so the distinction is harmful. Bottom line here: treat types and kinds as synonyms. The design of Haskell does, internally.

So.. does this mean that there are only two "things" now: "something"
and "type of something". And this "something" may be either value or
type. And when "something" is type, it's type is what was previously
called kind?

And the exact same type variable may denote the type of both
"something"-s (values and types) at the same time (i.e. in the one
expression)?

> - I think the crux of your question is why (Just t :: Maybe t) fails to type-check. We can see this in the type of Just: Just :: forall (a :: Type). a -> Maybe a. When we write `Just t` (for `t :: Type`), GHC sees `Just @Type t`, supplying the invisible instantiation for the `forall (a :: Type)` argument in Just's type. We can now see that `Just @Type t` will have type `Maybe Type`, just by substituting in Just's type. So saying `Just t :: Maybe t` will be rejected.
>
> - On the other hand, `Nothing :: Maybe t` is fine. We have `Nothing :: forall (a :: Type). Maybe a`, and so `Nothing :: Maybe t` really means `Nothing @t :: Maybe t`, and all is well.

Thanks a lot, I think that I understand now. And does the error:

coerce-existential-with-type-level-maybe.lhs:22:3: error:
    • Type variable ‘t’ is mentioned in the RHS,
        but not bound on the LHS of the family instance
    • In the type instance declaration for ‘ToType’
      In the instance declaration for ‘FromTypeMaybe ('Nothing @Type)’
   |
22 | > instance forall (t :: Type). FromTypeMaybe ('Nothing @Type) where
   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...

when i try to apply 'Nothing to @Type instead of @t occurs, because
full form of associated type family is

     type ToType ('Nothing @Type) = t

and variable 't' becomes unbound?

> I worry that there is more in your email that I haven't answered here. If so, please write back!
>
> Richard

From ietf-dane at dukhovni.org  Fri Dec 31 20:49:10 2021
From: ietf-dane at dukhovni.org (Viktor Dukhovni)
Date: Fri, 31 Dec 2021 15:49:10 -0500
Subject: [Haskell-cafe] Coercing existential according to type-level
 Maybe (re-post from h-beginners)
In-Reply-To: <CAFdVUFm4mSBgcULkQ7YyY-dhbmXVCnNB6umac-FCjJdhUbm=XA@mail.gmail.com>
References: <CAFdVUFkZtWHwJsfdRUNnQVA1q2qej7eL4suh7AcQwDAZrxQ26Q@mail.gmail.com>
 <010f017e0c38c22e-30a5eec7-850a-4f1f-af67-1ba48b123d55-000000@us-east-2.amazonses.com>
 <CAFdVUFm4mSBgcULkQ7YyY-dhbmXVCnNB6umac-FCjJdhUbm=XA@mail.gmail.com>
Message-ID: <Yc9sxhjtkCrmpIPf@straasha.imrryr.org>

On Fri, Dec 31, 2021 at 04:33:28PM +0300, Dmitriy Matrosov wrote:

> Thanks a lot, I think that I understand now. And does the error:
> 
> coerce-existential-with-type-level-maybe.lhs:22:3: error:
>     • Type variable ‘t’ is mentioned in the RHS,
>         but not bound on the LHS of the family instance
>     • In the type instance declaration for ‘ToType’
>       In the instance declaration for ‘FromTypeMaybe ('Nothing @Type)’
>    |
> 22 | > instance forall (t :: Type). FromTypeMaybe ('Nothing @Type) where
>    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...

The error is a technicality, it goes away if you give `Nothing` an
explicit type (kind):

    instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where
      type ToType ('Nothing :: Maybe t) = t
      fromTypeMaybe f _ x = Nothing

-- 
    Viktor.