- Libraries - Haskell.org

Package takeover request for rapid
by Markus Läll 19 May '22

19 May '22

Hi I would like to take over https://hackage.haskell.org/package/rapid The author of the package Ertugrul Söylemez, once an active member of the community perhaps best known for netwire, passed away in 2018. [1] The work required for the package thus far, and for which I've kept a fork for, is to bump version bounds as GHCs progress. [1] https://github.com/esoeylemez/rapid/pull/2#issuecomment-427065739 -- Markus Läll

5 7

unix maintenance
by Julian Ospald 18 May '22

18 May '22

Hi, I hereby request to be added as a unix maintainer. My past and current involvement with unix package and similar API can be seen here: * https://github.com/haskell/unix/commit/c7d88b3612fdf74a7964a670d6e79128f97f… * https://github.com/haskell/unix/pull/202 * https://github.com/haskell/unix/pull/110 * https://hackage.haskell.org/package/hpath-posix * https://hackage.haskell.org/package/streamly-posix I think it can be seen from the issue tracker that it's understaffed. Cheers, Julian

2 1

Bad default bitraverse
by Keith 07 Apr '22

07 Apr '22

The default `bitraverse` implementation should be removed. The default `bitraverse` is `bitraverse f g = bisequenceA . bimap f g`. But `bisequenceA` is an alias of `bisequence`, which in turn is `bitraverse id id`. Neither `bisequence` nor `bisequenceA` is a Bitraversable method, so they can't have alternative definitions. Sorry if this has already been mentioned. Sent from my phone with K-9 Mail.

3 3

[ANN] fresnel initial release
by Rob Rix 21 Feb '22

21 Feb '22

Hello! I’m pleased to announce the initial release of fresnel, an optics library optimizing for few dependencies, familiar tools, and decent error messages, without sacrificing functionality. fresnel is available at: - https://hackage.haskell.org/package/fresnel-0.0.0.0 - https://github.com/fresnel/fresnel/releases/tag/0.0.0.0 Feature requests, issues, and other feedback are welcome at https://github.com/fresnel/fresnel/issues Overview: - Most of the optic types from lens and optics. No Indexed*, however. - Compose optics using . much like in lens. - Decent error messages, much like in optics. - Few dependencies. I’m considering pulling At/Ixed into a new package to reduce the dependency list that much more, out of a desire to “pay for what you use.” I’m considering divesting the package of the profunctors dependency for much the same reason. - Named for a real-world optic which has saved countless lives by its use in lighthouses around the world. Best regards, Rob

1 0

[ANN] BNFC 2.9.4 released
by Andreas Abel 17 Feb '22

17 Feb '22

BNFC 2.9.4 is available at - https://hackage.haskell.org/package/BNFC-2.9.4 - https://github.com/BNFC/bnfc/releases/tag/v2.9.4 (binaries and changelog) Feedback welcome, problems at https://github.com/BNFC/bnfc/issues . The BNF Converter (bnfc) is a wizard generating syntax trees, parser and printer from a Labelled BNF (LBNF) grammar. It is currently able to generate Haskell, Agda, C, C++, Java, and OCaml representations. Supported parser generators: Happy, ocamlyacc, Menhir, ANTLR, CUP, Bison. More information: http://bnfc.digitalgrammars.com Changes in 2.9.4: - LBNF: empty tokens types are now forbidden [#388] - Agda: support position information via --functor [#405] - C/C++: use size_t and -Wsign-conversion [#391] - C++: repair broken --line-numbers [#390], regression in 2.9.2 by [#349] - Haskell: fix a problem with layout stop words and top-level layout [#399,#413] - Haskell: generated test parser can parse several files now [#400] - Java: use L.valueOf() instead of deprecated new L() for literal classes L [#402] - Ocaml: non-terminals in generated parser are now type-annotated [#407] - Ocaml: sanitize bound variables in define - Ocaml/Menhir: update parse error mechanism to Menhir 2021/12/30 [#414] Cheers, Andreas -- Andreas Abel <>< Du bist der geliebte Mensch. Department of Computer Science and Engineering Chalmers and Gothenburg University, Sweden andreas.abel(a)gu.se http://www.cse.chalmers.se/~abela/

1 0

Faster `elem` "Hack" for Data.Set?
by Viktor Dukhovni 30 Jan '22

30 Jan '22

In a recent "Folding the unfoldable" "gist": https://oleg.fi/gists/posts/2022-01-25-folding-unfoldable.html Oleg describes a way to make unboxed Vectors Foldable: There is another way to make Foldable work, with a data Hack a b where Hack :: U.Vector a -> Hack a a This is a two type-parameter wrapper, but the types are always the same! (I wish that could be a newtype). The Foldable instance is simply: instance U.Unbox a => Foldable (Hack a) where foldr f z (Hack v) = U.foldr f z v foldl' f z (Hack v) = U.foldl' f z v In the associated Reddit thread https://www.reddit.com/r/haskell/comments/sd6gel/comment/hudmsis/?utm_sourc… it was observed that a similar approach can be used to give Data.Set a performant `elem` method (code copied below my signature). It is somewhat tempting to consider whether the "Hack" ought to be built-in directly into the real Data.Set: https://www.reddit.com/r/haskell/comments/sd6gel/comment/huil070/?utm_sourc… type Set a = SetImpl a a data SetImpl a b where Bin :: {-# UNPACK #-} !Size -> !a -> !(SetImpl a) -> !(SetImpl a) -> SetImpl a a Tip :: SetImpl a a type Size = Int instance Ord a => Foldable (SetImpl a) where ... elem _ Tip = False elem x (Bin _ y l r) = case compare x y of EQ -> True LT -> elem x l GT -> elem x r ... This representation does not seem to carry any obvious runtime overhead, and gives Set a performant `elem` method. The only change from the status quo would be that folds would not be available for empty or singleton sets with non-Ord elements (currently possible with Set). How much of a loss would it be to constrain the element type of empty and singleton sets used in folds? Are there other issue that make the above impractical? -- Viktor. type OSet a = OrdSet a a data OrdSet a b where OSet :: Set.Set a -> OrdSet a a instance Ord a => Foldable (OrdSet a) where fold (OSet xs) = fold xs foldMap f (OSet xs) = foldMap f xs foldMap' f (OSet xs) = foldMap' f xs foldr f z (OSet xs) = foldr f z xs foldr' f z (OSet xs) = foldr' f z xs foldl f z (OSet xs) = foldl f z xs foldl' f z (OSet xs) = foldl' f z xs foldr1 f (OSet xs) = foldr1 f xs foldl1 f (OSet xs) = foldl1 f xs toList (OSet xs) = toList xs null (OSet xs) = null xs length (OSet xs) = length xs -- The point of the exercise is `elem` elem e (OSet xs) = Set.member e xs maximum (OSet xs) = maximum xs minimum (OSet xs) = minimum xs sum (OSet xs) = sum xs product (OSet xs) = product xs instance Eq a => Eq (OSet a) where (OSet xs) == (OSet ys) = xs == ys instance (Eq a, Ord a) => Ord (OSet a) where compare (OSet xs) (OSet ys) = compare xs ys empty :: Ord a => OSet a empty = OSet Set.empty singleton :: Ord a => a -> OSet a singleton = OSet . Set.singleton fromList :: Ord a => [a] -> OSet a fromList = OSet . Set.fromList (\\) :: Ord a => OSet a -> OSet a -> OSet a (OSet xs) \\ (OSet ys) = OSet (xs Set.\\ ys) alterF :: (Ord a, Functor f) => (Bool -> f Bool) -> a -> OSet a -> f (OSet a) alterF f x (OSet xs) = fmap OSet $ Set.alterF f x xs ...

5 6

Adding a "Map k a -> Set (Arg k a)" function to containers
by Joseph C. Sible 27 Jan '22

27 Jan '22

I opened https://github.com/haskell/containers/issues/814 about adding this function to the containers package: import qualified Data.Map.Internal as Map import qualified Data.Set.Internal as Set import Data.Semigroup (Arg(..)) mapToArgSet :: Map.Map k a -> Set.Set (Arg k a) mapToArgSet Map.Tip = Set.Tip mapToArgSet (Map.Bin sz k v l r) = Set.Bin sz (Arg k v) (mapToArgSet l) (mapToArgSet r) Does anyone have any suggestions or improvements for this? In particular, I'm sure there's a less clunky name that I just can't think of. Thanks, Joseph C. Sible

2 2

whither is an MTL that supports transformers >= 0.6?
by Carter Schonwald 21 Jan '22

21 Jan '22

Hey All, I was looking around and noticed we still lack that ... anyone have decent visibility ? -Carter

2 2

Proposal: export liftA2 from Prelude
by Andreas Abel 14 Jan '22

14 Jan '22

Proposal: export liftA2 from Prelude. More information and discussion here: https://gitlab.haskell.org/ghc/ghc/-/issues/20945 Discussion period 2 weeks TL;DR - Fixes weird qualification in warning • No explicit implementation for either ‘<*>’ or ‘GHC.Base.liftA2’ • In the instance declaration for ‘Applicative <Foo>’ - Was considered for GHC 8.2 but never followed up

2 1

Takeover of cryptonite and memory
by Hécate 09 Jan '22

09 Jan '22

Hello Hackage admins, Several board members of the Haskell Foundation have tried for many months to contact Vincent Hanquez regarding his cryptography packages, that have become cornerstones of the ecosystem and of industrial Haskell products. Recently, I have received complaints and questions about those packages being major blockers for the adoption of newer GHC versions. I have thus made another home for those packages with the explicit aim of diversifying the ownership and maintenance so that we do not have such a high bus factor. I would like to start a Hackage takeover procedure for the following packages: * cryptonite * memory Their new home would be the haskell-cryptography GitHub organisation, and emails have been sent to past contributors, in order to maintain continuity in the development teams. My Hackage username is "hecate". Chris Dornan (in CC) is also involved, and his username is "ChrisDornan". Moreover, as a board member of the Haskell Foundation, I intend to provide resources to help coordination between the stakeholders of these packages, in the community and industry. We will be at your disposal for any question. Cheers. Hécate ✨ 🐦: @TechnoEmpress IRC: Hecate WWW: https://glitchbra.in RUN: BSD

1 0