April 2020 - Libraries

Improving the instances of Data.Functor.{Product,Sum}
by chessai . 25 Jan '21

25 Jan '21

Consider the Eq instance for these types. Currently we rely on: (Eq1 f, Eq1 g, Eq a) But some potential improvements include changing to: (Eq (f (g a))) (FlexibleContexts) or (forall x. Eq x => Eq (f x), forall x. Eq x => Eq (g x), Eq a) (QuantifiedConstraints) There was a discussion sometime last year about the same thing regarding Semigroup/Monoid instances for `Compose` [1]. Additionally, the question has been raised again for Data.Functor.{Product,Sum} on Gitlab [2, 3]. There has been no consensus in either case, but that's not too worrying as both discussions have been brief. I'm currently not happy with the {Eq,Ord,Show}{1,2} family of classes, and would hope to work toward their removal, or at least the shrinking of their presence in base. Even though the linked proposals are about a single type, I think it's important that we come up with a decision and stick with it. Having different APIs for different types here would be pretty confusing, and some could even say sloppy. Please let me know your thoughts. [1]: https://mail.haskell.org/pipermail/libraries/2019-July/029771.html [2]: https://gitlab.haskell.org/ghc/ghc/issues/17015 [3]: https://gitlab.haskell.org/ghc/ghc/merge_requests/1704

10 22

Deprecating fromIntegral
by Niklas Hambüchen 12 Aug '20

12 Aug '20

This is not a joke. I just found a bug in base (https://ghc.haskell.org/trac/ghc/ticket/14262) import System.IO hWaitForInput stdin 4294968296 This code should wait for 49.something days, but it waits for 1 second. It is caused by a quick use of `fromIntegral` to "convert" `Int -> CInt` (where CInt = Int32), causing an overflow. I argue that `fromIntegral` causes unnoticed data corruption without any warning, and thus are worse than partial functions. In this case, this data corruption occurs in the most fundamental code that we all use and have to rely upon (`base`). So I propose that we add a deprecation pragma to `fromIntegral` (however, keeping it forever, like Java does, as there's no benefit to removing it, we just want that people use safer functions over time), and instead provide a `safeFromIntegral` that can only widen ranges, and one or more `unsafeFromIntegral` or appropriately named functions that can error, wrap, return Maybe, or have whatever desired behaviour when the input value doesn't fit into the output type. For some inspiration, `foundation` provides ideas in that direction: http://hackage.haskell.org/package/basement-0.0.2/docs/Basement-From.html http://hackage.haskell.org/package/basement-0.0.2/docs/Basement-IntegralCon… It is a bit funny how we argue that Haskell is good for high assurance programming, and we build all sorts of fancy constructs to eliminate more run-time errors, when in fact we do worse than C in detecting errors in the most basic types a computer can use, such as converting between 64-bit and 32-bit integers. Let's fix that. It avoids real problems in real production systems that are difficult to debug when they happen (who writes a unit test checking that a timeout of 50 days still works? This is the kind of stuff where you have to rely on -- very basic -- types). I'd like to probe support for such a change before doing any work on it. Niklas

18 58

Deprecate First and Last in Data.Monoid
by Andrew Martin 13 Jun '20

13 Jun '20

I propose that the data types First and Last, provided by Data.Monoid, be marked deprecated in GHC 8.6 and removed in GHC 8.10. The Semigroup-Monoid Proposal (SMP) brought about changes that, I will argue, make these data types (1) unneeded and (2) confusing. Why are they no longer needed? Data.Semigroup provides two identically named data types (First and Last). These have Semigroup instances matches what their names suggest. Additionally, SMP corrects the Monoid instance for Maybe so that it now lifts Semigroup instances instead of Monoid instances. What this means is that, assuming the following imports: import qualified Data.Monoid as M import qualified Data.Semigroup as S We have the following equivalences: M.First a === Maybe (M.First a) M.Last a === Maybe (M.Last a) When I say "equivalence", I mean that their Monoid instances have the same behavior. Their Show/Read instances are certainly different, and I’m not sure about their Ord instances. Getting back to the second reason, removing these data types would eliminate confusion. It’s strange that Semigroup is a superclass of Monoid, yet they have Data types with conflicting names defined in their respective modules. When you see the data type First, you cannot tell what someone is talking additional context. In general, base strives to avoid duplicate identifiers. The only other exception to this rule I can think of is that Bifunctor and Arrow both use the identifiers first and second. But, the situation with Data.Semigroup and Data.Monoid is higher impact since people are more likely to import these modules unqualified together. (As an aside, and the confusion I’m talking about here isn’t entirely hypothetical. I got tripped up by this when I first started using the semigroups library. I had to train myself to stop importing Data.Monoid unqualified, because it kept stealing these identifiers) Again, the two reasons are that these are no longer necessary and that they cause confusion. I would appreciate any feedback, including simple nods of agreement or disagreement. Thanks. -- -Andrew Thaddeus Martin

7 8

Re: [core libraries] Adding Backwards to base, re-export from Control.Applicative
by Baldur Blöndal 06 Jun '20

06 Jun '20

I'll CC Haskell Libraries þri., 12. nóv. 2019 kl. 22:14 skrifaði Ryan Scott <ryan.gl.scott(a)gmail.com>: > This discussion definitely belongs on the mailing list, yes. > > Ryan > > On Tue, Nov 12, 2019 at 11:59 AM chessai . <chessai1996(a)gmail.com> wrote: > >> I support this. +1 >> >> Should we copy in the libraries mailing list? >> >> On Tue, Nov 12, 2019, 5:56 AM Baldur Blöndal <baldurpet(a)gmail.com> wrote: >> >>> Is it time to move Control.Applicative.Backwards module from >>> transformers to base, and maybe re-export it from Control.Applicative. >>> >>> It's an interesting, important, simple property of Applicative that they >>> can be run backwards. >>> >>> -- >>> You received this message because you are subscribed to the Google >>> Groups "haskell-core-libraries" group. >>> To unsubscribe from this group and stop receiving emails from it, send >>> an email to haskell-core-libraries+unsubscribe(a)googlegroups.com. >>> To view this discussion on the web visit >>> https://groups.google.com/d/msgid/haskell-core-libraries/CAK9DwL9vPwA%3DJ%3… >>> <https://groups.google.com/d/msgid/haskell-core-libraries/CAK9DwL9vPwA%3DJ%3…> >>> . >>> >> -- >> You received this message because you are subscribed to the Google Groups >> "haskell-core-libraries" group. >> To unsubscribe from this group and stop receiving emails from it, send an >> email to haskell-core-libraries+unsubscribe(a)googlegroups.com. >> To view this discussion on the web visit >> https://groups.google.com/d/msgid/haskell-core-libraries/CAD34_kK6QgQ%2BQmg… >> <https://groups.google.com/d/msgid/haskell-core-libraries/CAD34_kK6QgQ%2BQmg…> >> . >> >

8 7

Bifoldable instance for Map
by Joseph C. Sible 03 Jun '20

03 Jun '20

I'd like to propose a change to the containers package: adding a Bifoldable instance to Map. I briefly mentioned this on Reddit [1] and no obvious problems were brought up. I submitted a PR implementing it [2]. This seems like an obvious and straightforward instance to me. Thoughts? Joseph C. Sible [1]: https://old.reddit.com/r/haskell/comments/fsgqd6/monthly_hask_anything_apri… [2]: https://github.com/haskell/containers/pull/714

5 18

Stop the deprecation of Data.Monoid.{First,Last}
by Simon Jakobi 26 May '20

26 May '20

Hi! For two years there has been a plan ([1], [12]) to deprecate and eventually remove Data.Monoid.{First,Last} ([13]), in order to resolve the name conflict with Data.Semigroup.{First,Last} ([14]). While implementing ([2]) this plan in GHC and the core libraries, and testing the migration in a few packages, I encountered some difficulties which made me question whether the benefits of the deprecation would outweigh its costs: * Code that previously used Data.Monoid.{First,Last} becomes noisier. See e.g. a patch to migrate the summoner package ([3]). * Higher Kinded Data applications of D.M.{First,Last} such as in higgledy ([4]) are difficult to migrate, partly due to missing instances for D.S.{First,Last} ([5]). * Additionally, there's an important difference in the strictness of the Semigroup instances for D.M.{First.Last} and the suggested replacement of (Maybe D.S.{First,Last}): [6], [9]. In sum, the existing migration story is painful in multiple ways. Moreover, D.S.{First,Last} don't actually seem to be useful in practice. I couldn't find any code using them except to define the usual newtype instances. In consequence, I think the deprecation should be scrapped, and the documentation of base updated accordingly. Regarding alternative ways to resolve the name clash, I see the following options: A) Deprecate and remove D.S.{First,Last}. B) Rename D.S.{First,Last}. C) Do nothing. Haskellers are already used to handling the name clash, usually via qualified imports. I would also like to mention that the process surrounding the deprecation has IMHO been somewhat less than ideal: 1. The deprecation was apparently decided without much research on how D.M.{First,Last} are being used in the ecosystem, and without properly testing the suggested migration. 2. Apart from the brief discussion on the libraries mailing list and changes to the haddocks ([7], [8]) for D.M.{First,Last}, there appears not to have been any announcement of the planned deprecation. 3. When, shortly after the haddocks changes, the strictness differences between D.M.First and (Maybe D.S.First) were pointed out on the libraries mailing list ([9]), the deprecation was apparently not reconsidered, nor the documentation updated. I myself wasn't aware of this aspect while I worked on the deprecation! 4. I should have sent this email 9 months ago, when I stopped working on the deprecation. The incorrect information in the haddocks has since caused some confusion ([10], [11]). What do you think? Cheers, Simon [1] https://mail.haskell.org/pipermail/libraries/2018-April/028712.html [2] https://gitlab.haskell.org/ghc/ghc/-/merge_requests/842 [3] https://github.com/kowainik/summoner/pull/319 [4] https://github.com/i-am-tom/higgledy/issues/4 [5] https://gitlab.haskell.org/ghc/ghc/issues/16636 [6] https://gitlab.haskell.org/ghc/ghc/issues/17967 [7] https://gitlab.haskell.org/ghc/ghc/-/commit/e34e30e492a7bc40e3da5a05b8e297a… [8] https://gitlab.haskell.org/ghc/ghc/-/commit/cf35ab9ac7e0f33e39af6af16ecf850… [9] https://mail.haskell.org/pipermail/libraries/2018-May/028818.html [10] https://github.com/conal/checkers/issues/44 [11] https://gitlab.haskell.org/ghc/ghc/issues/18041 [12] https://gitlab.haskell.org/ghc/ghc/issues/15028 [13] http://downloads.haskell.org/~ghc/8.10.1/docs/html/libraries/base-4.14.0.0/… [14] http://downloads.haskell.org/~ghc/8.10.1/docs/html/libraries/base-4.14.0.0/…

6 13

What do you assume when you see fromListN in a library?
by Carter Schonwald 23 May '20

23 May '20

Hey everyone: When you see fromListN as a function in a library, do you assume / presume it’s expecting an exactly N element list ? Or do you expect/tolerate other behavior ? Should it reject shorter lists? Should it truncate or reject longer lists? A corner case of this came up in some bug discussion I was having regarding vector, and I shall claim and or presume that most folks assume exact size with prompt rejection of too long or too short. Thoughts please ? -Carter

13 32

Adding new contructors to IOMode to support "don't overwrite if already exists" behavior
by Grey Mitchell 22 May '20

22 May '20

The current behavior for System.IO.openFile will either truncate an existing file (with WriteMode) or append new content to the end (with AppendMode). However, there's another behavior that's available from the underlying API: signal an error when the file already exists. I poked around at the code and i think that with a couple extra variants of IOMode, this behavior could be added with a relatively small patch. I have a branch pushed where i added this behavior: https://gitlab.haskell.org/QuietMisdreavus/ghc/-/commit/1ff18d4d3fc63f42c37… I'm a relative newcomer to contributing to GHC or the base library, so if i'm missing something in my patch please let me know. Specifically, i would like to know is there's a place i can add a test for this behavior. I'm also open to changing the names of the new IOModes - this was just something i wrote in to get something working. Looking forward to working with maintainers to get this added! Thanks, Grey Mitchell (@QuietMisdreavus)

5 8

No fixity declaration for deepseq
by Christiaan Baaij 13 Apr '20

13 Apr '20

Hello list, Is the following behavior intended? or an oversight? Prelude Control.DeepSeq> tail ((undefined :: ()) `seq` 1 : []) *** Exception: Prelude.undefined CallStack (from HasCallStack): error, called at libraries/base/GHC/Err.hs:80:14 in base:GHC.Err undefined, called at <interactive>:5:8 in interactive:Ghci2 Prelude Control.DeepSeq> tail ((undefined :: ()) `deepseq` 1 : []) [] If you're wondering what's happening, there is a (builtin) fixity declaration for 'seq': infixr `seq` 0 But there isn't one for `deepseq`. So undefined `seq` 1 : [] is parsed as undefined `seq` (1 : []) while undefined `deepseq` 1 : [] is parsed as (undefined `deepseq` 1) : [] In a real-life use-case, changing `seq` to `deepseq` actually resulted in a (very unanticipated) space-leak for me. So again, is the lack of fixity declaration for deepseq intentional? or an accidental omission? Best regards, Christiaan

2 1

On the state of 'tar'
by hasufell 08 Apr '20

08 Apr '20

Friends, 'tar' [0][1] is an excellent native haskell implementation of the tar format. However, there are currently a lot of unattended issues: * unicode filepaths broken due to Char8 use [2] * executable bits handled improperly [3] * no support for long filepath extension [4][5] * doesn't handle hardlinks properly [6] * handles symbolic links too strictly [7] Most of these issues are 2 to 4 years old, some of them have PRs that have never been reviewed. 'tar' fails to unpack our own ghc bindists even [4]. I consider it, in this state, too unreliable for production use. Since it is in the 'haskell' namespace on github and probably the first hit on hackage, this needs to be improved quickly, IMO. Users currently can use tar-bytestring [8] (no windows support) or libarchive [9] (not a native implementation), but 'tar' should ultimately be fixed and maintained properly. -- [0] https://hackage.haskell.org/package/tar [1] https://github.com/haskell/tar [2] https://github.com/haskell/tar/issues/6 [3] https://github.com/haskell/tar/issues/25 [4] https://github.com/haskell/tar/issues/49 [5] https://github.com/haskell/tar/issues/27 [6] https://github.com/haskell/tar/issues/51 [7] https://github.com/haskell/tar/issues/32 [8] https://github.com/hasufell/tar-bytestring [9] https://hackage.haskell.org/package/libarchive -- Cheers, Julian

4 6