- Libraries - Haskell.org

Proposal: Export Solo from Data.Tuple
by David Feuer 03 Jan '21

03 Jan '21

GHC.Tuple now exports data Solo a = Solo a for use as the canonical lifted unary tuple. I propose to export it from Data.Tuple. David

3 2

withFile defeats dead handle closure
by David Feuer 31 Dec '20

31 Dec '20

withFile keeps the handle it creates alive until the user action completes. If we want to avoid this, we can. All that's required is to capture the weak reference that holds the handle's finalizer. Then instead of closing the handle in the end (or on exception) using hClose, withFile can run the handle's finalizer. Should we do this? Or does it run too much against the idea that handles should be managed as explicitly as possible?

7 12

containers: intersections for Set, along with Semigroup newtype
by Reed Mullanix 29 Dec '20

29 Dec '20

Hey all, I've found myself reaching for the following function a couple of times now, so I figured it might make a good addition. intersections :: Ord a => NonEmpty (Set a) -> Set a intersections (s :| ss) = Foldable.foldl' intersection s ss In a similar vein, we may as well add the following newtype + instance combo: newtype Intersection a = Intersection { getIntersection :: Set a } instance (Ord a) => Semigroup (Intersection a) where (Intersection a) <> (Intersection b) = Intersection $ intersection a b stimes = stimesIdempotent Would love to hear everyone's thoughts on this! Thanks Reed Mullanix

17 37

Improve documentation for Real
by David Feuer 27 Dec '20

27 Dec '20

The Real class has one method: -- | the rational equivalent of its real argument with full precision toRational :: a -> Rational This is ... pretty weird. What does "full precision" mean? For integral and floating point types, it's fine. It's not at all meaningful for 1. Computable reals 2. Real algebraic numbers 3. Real numbers expressible in radicals 4. Rational numbers augmented with some extra numbers like pi 5. Geometrically constructable reals 6. Etc. Can we settle on a meaning for toRational? The properFraction method of the RealFrac class has basically the same issue.

4 6

Why are `sum` and `product` defined via foldMap' and not foldl'?
by Viktor Dukhovni 23 Dec '20

23 Dec '20

Is there a compelling reason for: sum = getSum #. foldMap' Sum product = getProduct #. foldMap' Product rather than: sum = foldl' (+) 0 product = foldl' (*) 1 A quick ghci session with today's GHC head yields: λ> import qualified Data.Foldable as F λ> :set +s λ> F.sum [0..10000000] 50000005000000 (2.98 secs, 1,612,368,368 bytes) λ> F.foldl' (+) 0 [0..10000000] 50000005000000 (0.28 secs, 880,065,112 bytes) The `foldl'` variant looks substantially more efficient (at least for lists), is there some important context in which `foldMap'` is preferable? -- Viktor.

6 8

Re: type class Boolean
by Johannes Waldmann 22 Dec '20

22 Dec '20

[I sent this to -cafe by mistake] > most useful kind of instance would be symbolic booleans Yes. Ersatz has this: https://hackage.haskell.org/package/ersatz-0.4.8/docs/Ersatz-Bit.html#t:Boo… I also use this class (re-exported) in https://hackage.haskell.org/package/obdd Then modules typically start with import Prelude hiding ( not, and, or, (&&), (||) ) -- possibly more import Ersatz slightly annoying but you get used to it ... - J.

1 0

Numeric supports base 8, 10, 16 but not 2 -- why?
by Artem Pelenitsyn 07 Dec '20

07 Dec '20

Dear Libraries, I noticed the Numeric module has special-cased functions to read and show integral types in bases 8, 10, 16 but not for base 2. There are also generic-over-base versions, so an interested client can implement the special case for base 2 themselves with little hassle. Still, I think base 2 is common enough that we could support it along with base 8, 10, 16 out of the box. What do you think? I'm happy to submit a merge request if you concur. Kind regards, Artem Pelenitsyn

8 8

Proposal for containers: Add 'pop' function to Data.Map
by Martijn Bastiaan 07 Dec '20

07 Dec '20

Hi all, Proposal: * Add `pop` and `popWithDefault` to `Data.Map` and `Data.IntMap`. * See https://github.com/haskell/containers/pull/757 for exact definition Why: * They're useful functions I expected to be in `Data.Map` and `Data.IntMap`. (This might be influenced by the fact that they're defined on Python's `dict`.) * Their implementations (~ `updateLookupWithKey (\_ _ -> Nothing)`) are harder to parse than a simple `pop`, which should help Haskell codebases become a bit cleaner :). * Their implementations are a bit non-obvious. My first instinct was to write `(Map.lookup ..., Map.delete ...)`, which would have done two traversals. Having "properly" implemented functions in the lib would prevent people from writing their own suboptimal ones. Details and implementation: * https://github.com/haskell/containers/pull/757 Kind regards, Martijn Bastiaan

11 28

containers: symmetricDifference for Set and HashSet
by Ben Franksen 01 Dec '20

01 Dec '20

Would it make sense to add a function like the following to containers: symmetricDifference :: Set a -> Set a -> (Set a, Set a, Set a) symmetricDifference a b = (a \\ b, a `intersection` b, b \\ a) with the idea that this can be implemented more efficiently as a primitive than the above specification? (And similarly for HashSet.) If this is the case, then perhaps difference and intersection could be defined in terms of this new primitive: difference a b = let (r, _, _) = symmetricDifference in r intersection a b = let (_, r, _) = symmetricDifference in r *if* it turns out that this does not degrade performance. Cheers Ben

4 4

MonadZip laws
by Joseph C. Sible 27 Nov '20

27 Nov '20

Are either of these statements implied by the MonadZip laws? I don't see a way that they would be. mzipWith f (return x) (return y) = return (f x y) munzip (return (x, y)) = (return x, return y) If so, how? If not, do they make sense to add as laws of their own? Joseph C. Sible

1 0