- Libraries - Haskell.org

Correct behaviour of Bounded (Down a)
by David Beacham 22 Sep '20

22 Sep '20

Hi all, The current instance for `Bounded a => Bounded (Down a)` derives the `minBound` and `maxBound` exactly as they are for the underlying type `a` where I think they should be flipped to respect the flipped ordering of `Down a`? I have a feeling this has been come up in some other context/list before but I couldn't find a reference to it when searching - so sorry if this is a duplicate. I've got a corresponding MR here: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4081 Thanks, David.

9 15

[ANN] bytestring-0.11.0.0-rc1
by Andrew Lelechenko 19 Sep '20

19 Sep '20

On behalf of the maintainers team I'm happy to announce bytestring-0.11.0.0-rc1: https://github.com/haskell/bytestring/tree/0.11.0.0-rc1 This is a first major release since 2012, so I would like to encourage everyone to give it a try before it is shipped with GHC 9.0. The update focuses on performance improvements and removes several deprecated functions and modules. Changelog: https://github.com/haskell/bytestring/blob/0.11.0.0-rc1/Changelog.md Diff: https://github.com/haskell/bytestring/compare/0.10.12.0...0.11.0.0-rc1 Here is an example of cabal.project: packages: . source-repository-package type: git location: https://github.com/haskell/bytestring tag: 0.11.0.0-rc1 allow-newer: *:bytestring And an example of stack.yaml: resolver: nightly-2020-09-16 packages: - . extra-deps: - github: haskell/bytestring commit: 96c95391025c1ce2240f6dc7bcad06d4191e7793 - github: haskell/cabal commit: 5139d6e72d391bffa3cf06f08884277799eb0b45 subdirs: - Cabal - binary-0.8.8.0 - directory-1.3.6.0 - text-1.2.3.2 - unix-2.7.2.2 - parsec-3.1.14.0 - process-1.6.9.0 allow-newer: true Best regards, Andrew

3 2

What to do with Ord1 (Down a) instance
by Fumiaki Kinoshita 18 Sep '20

18 Sep '20

I was looking at the list of highest priority issues, and I noticed that one of them is blocked for a long time: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/2158 Is this something we can submit to new core-libraries-proposals repository ( https://github.com/haskell-core/core-libraries-proposals) to get more attention?

2 1

naturalToWord vs 'clampNaturalToWord'
by Keith 16 Sep '20

16 Sep '20

The short of it is, clampNaturalToWord :: Natural → Word clampNaturalToWord n = case n of NatS# w -> W# w _ -> maxBound results in much better space and time use than naturalToWord, which always takes the least significant Word of the Natural. Because naturalToWord takes the least significant Word, you always have to check for size before conversion. Even though you do check, GHC has to assume that, after conversion, the big Natural could have resulted in a small Word and will uselessly duplicate all branches for both cases. Is there anything wrong with clamping by default in this case? --Keith Sent from my phone with K-9 Mail.

3 2

Getting comonad into base
by Sandy Maguire 11 Sep '20

11 Sep '20

Hi all, I frequently regret the lack of having the Comonad class in base. Are there any good reasons for its absence? If not, I can get started on a patch. Best, Sandy

3 4

clamp function in base
by Sandy Maguire 11 Sep '20

11 Sep '20

Hi all, It seems to me that base is missing the very standard function `clamp :: Ord a => a -> a -> a -> a`: ```haskell clamp :: Ord a => a -> a -> a -> a clamp low high = min high .max low ``` I propose it be added to Data.Ord. It's useful, generic, and non-trivial to get right (the "big" number goes with "min" -- causes me cognitive dissonance every time.) Thanks, Sandy

11 20

Operator precedence help
by David Feuer 04 Sep '20

04 Sep '20

I'm trying to work out appropriate precedences for operators and pattern synonyms in my brand-new compact-sequences package. I currently have stacks and queues, but I will soon have deques, so let's pretend. For consistency, operators will match pattern synonyms. (<|), pattern (:<) :: a -> Deque a -> Deque a (|>), pattern (:>) :: Deque a -> a -> Deque a :< and :> need to have different precedence to allow things like a :< b :< xs :> c :> d to work nicely, but what numbers should I pick? I also have cons and snoc functions. Should I give their backticked spellings fixity declarations? If so, with what precedences?

9 21

Fwd: The Char Kind: proposal
by Daniel Rogozin 31 Aug '20

31 Aug '20

Greetings, I would like to propose and discuss several changes related to the character kind. Some of those changes were implemented jointly with Rinat Stryungis, my Serokell teammate. The purpose of this patch is to provide a possibility of analysing type-level strings (symbols) as term-level ones. This feature allows users to implement such programs as type-level parsers. One needs to have full-fledged support of type-level characters as well as we already have for strings and numbers. In addition to this functionality, it makes sense to introduce the set of type-families, counterparts of functions defined in the Data.Char module in order to work with type-level strings and chars as usual (more or less). For more convenience, it’s worth having some of the character-related type families as built-ins and generating the rest of ones as type synonyms. The patch fixes #11342, an issue opened by Alexander Vieth several years ago. In this patch, we introduced the Char Kind, a kind of type-level characters, with the additional type-families, type-level counterparts of functions from the `Data.Char` module. In contrast to Vieth’s approach, we use the same Char type and don’t introduce the different `Character` kind. We provide slightly more helpers to work with the Char kind, see below. You may take a look at this merge request with proposed updates: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3598. First of all, we overview the additional type families implemented by us in this patch. type family CmpChar (a :: Char) (b :: Char) :: Ordering Comparison of type-level characters, as a type family. A type-level analogue of the function `compare` specified for characters. type family LeqChar (a :: Char) (b :: Char) :: Bool This is a type-level comparison of characters as well. `LeqChar` yields a Boolean value and corresponds to `(<=)`. type family ConsSymbol (a :: Char) (b :: Symbol) :: Symbol This extends a type-level symbol with a type-level character type family UnconsSymbol (a :: Symbol) :: Maybe (Char, Symbol) This type family yields type-level `Just` storing the first character of a symbol and its tail if it is nonempty and `Nothing` otherwise. Type-level counterparts of the functions `toUpper`, `toLower`, and `toTitle` from 'Data.Char'. type family ToUpper (a :: Char) :: Char type family ToLower (a :: Char) :: Char type family ToTitle (a :: Char) :: Char These type families are type-level analogues of the functions `ord` and `chr` from Data.Char respectively. type family CharToNat (a :: Char) :: Nat type family NatToChar (a :: Nat) :: Char A type-level analogue of the function `generalCategory` from `Data.Kind`. type family GeneralCharCategory (a :: Char) :: GeneralCategory The second group of type families consists of built-in unary predicates. All of them are based on their corresponding term-level analogues from `Data.Char`. The precise list is the following one: type family IsAlpha (a :: Char) :: Bool type family IsAlphaNum (a :: Char) :: Bool type family IsControl (a :: Char) :: Bool type family IsPrint (a :: Char) :: Bool type family IsUpper (a :: Char) :: Bool type family IsLower (a :: Char) :: Bool type family IsSpace (a :: Char) :: Bool type family IsDigit (a :: Char) :: Bool type family IsOctDigit (a :: Char) :: Bool type family IsHexDigit (a :: Char) :: Bool type family IsLetter (a :: Char) :: Bool We also provide several type-level predicates implemented via the `GeneralCharCategory` type family. type IsMark a = IsMarkCategory (GeneralCharCategory a) type IsNumber a = IsNumberCategory (GeneralCharCategory a) type IsPunctuation a = IsPunctuationCategory (GeneralCharCategory a) type IsSymbol a = IsSymbolCategory (GeneralCharCategory a) type IsSeparator a = IsSeparatorCategory (GeneralCharCategory a) Here is an example of an implementation: type IsMark a = IsMarkCategory (GeneralCharCategory a) type family IsMarkCategory (c :: GeneralCategory) :: Bool where IsMarkCategory 'NonSpacingMark = 'True IsMarkCategory 'SpacingCombiningMark = 'True IsMarkCategory 'EnclosingMark = 'True IsMarkCategory _ = 'False Built-in type families I described above are supported with the corresponding definitions and functions in `compiler/GHC/Builtin/Names.hs`, `compiler/GHC/Builtin/Types.hs`, and `compiler/GHC/Builtin/Types/Literals.hs`. In addition to type families, our patch contain the following updates: 1. parsing the 'x' syntax 2. type-checking 'x' :: Char 3. type-checking Refl :: 'x' :~: 'x' 4. Typeable / TypeRep support 5. template-haskell support 6. Haddock related updates 7. tests At the moment, the merge request has some minor imperfections for polishing and improvement, but we have a prototype of a possible implementation. The aim of my email is to receive your feedback on this patch. Kind regards, Danya Rogozin.

3 2

Consider adding `classify`.
by Ignat Insarov 24 Aug '20

24 Aug '20

Hello. There has been [a question on Stack Overflow][1] asking for a way to group a list by an equivalence relation. Several answers were proposed over time, and I too [have offered a variant][2]. [I also wrote a benchmark.][3] I propose that the function be added to the standard libraries. [1]: https://stackoverflow.com/q/8262179 [2]: https://stackoverflow.com/a/57761458 [3]: https://github.com/kindaro/classify-benchmark.git

4 4

Consider adding `converge` and friends.
by Ignat Insarov 24 Aug '20

24 Aug '20

Hello… This function first appeared _(to my knowledge)_ in [a Stack Overflow answer][1]. I found it useful several times, and eventually [I extended it to a family of 4 derived functions][2]: `converge`, `convergeBy`, `fixp` and `fixpBy`. * `convergeBy` is like `takeWhile` but with a binary predicate. * `converge` cuts a list at a point where it starts to repeat itself. * `fixp` takes the last element. These operations are useful in many practical cases. For example, the Newton-Raphson approximation method: λ r a = \x -> (x + a/x) / 2 λ fixp (r 2) 1 1.414213562373095 Or let us compute the alternating group A₄: λ import qualified Data.List as List λ xs */ ys = fmap (xs !!) ys λ generate1 gens elems = List.union elems [ elem */ gen | elem <- elems, gen <- gens ] λ ε = [0.. 3] λ rota3 = [1, 2, 0, 3] λ rota3' = [0, 2, 3, 1] λ length $ fixp (generate1 [rota3, rota3']) [ε] 12 I propose adding these functions to `Data.List`. [1]: https://stackoverflow.com/a/7443379 [2]: https://stackoverflow.com/q/48353457

4 3