- Libraries - Haskell.org

Make sameNat proxy-polymorphic
by Andrew Lelechenko 15 Aug '19

15 Aug '19

Hi all, Currently base:GHC.TypeNats.sameNat is implemented as follows: sameNat :: (KnownNat a, KnownNat b) => Proxy a -> Proxy b -> Maybe (a :~: b) sameNat x y | natVal x == natVal y = Just (unsafeCoerce Refl) | otherwise = Nothing There are applications, when more flexibility is desirable. I propose to change sameNat's type to sameNat :: (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Maybe (a :~: b) It does not require any changes in the implementation, because natVal is already "proxy-polymorphic": natVal :: forall n proxy. KnownNat n => proxy n -> Natural Best regards, Andrew

4 3

indexM or (!?)-style accessor for arrays?
by Zemyla 13 Aug '19

13 Aug '19

This is an issue I originally proposed on GHC Trac, but I'm posting it here because (I think) the Data.Array package is under the purview of the Libraries committee. The vector package has indexM and its cousins so that a user can be strict in the array without necessarily being strict in the value retrieved from that array. Arrays don't have that sort of thing, meaning that anything you do that takes an array will necessarily leave references to the array unless you force the whole thing, and that's not only inefficient, it's untenable for general libraries. What I'm thinking is that the IArray class should have a function like unsafeAtM :: (Array a e, Ix i, Applicative m) => a i e -> Int -> m e For compatibility with older code that wouldn't necessarily define this but would define unsafeAt, we'd have the default implementation unsafeAtM a !n = pure (unsafeAt a n) Also, you could have unsafeAt defined in terms of unsafeAtM, so the minimal implementation could require only one of them: unsafeAt = (coerce :: (a i e -> Int -> Identity e) -> a i e -> Int -> e) unsafeAtM Also, (!?) would be a "safe" indexing tool for arrays, which would incidentally also force the array without forcing the value inside. You would have (!?) :: (Array a e, Ix i) => a i e -> i -> Maybe e (!?) a e = case bounds a of p@(l, u) -> case inRange p e of True -> unsafeAtM arr $ unsafeIndex p e False -> Nothing

2 4

Add instance Eq1 Complex, Show1 Complex, and Read1 Complex
by Dannyu NDos 11 Aug '19

11 Aug '19

instance Eq1 Complex where liftEq f (x :+ y) (u :+ v) = f x u && f y v instance Show1 Complex where liftShowsPrec sp _ p (x :+ y) = showParen (p >= 6) (sp p x . showString " :+ " . sp p y) instance Read1 Complex where liftReadPrec rp _ = parens $ prec 6 $ do x <- step rp Symbol ":+" <- lexP y <- step rp return (x :+ y) liftReadList = liftReadListDefault liftReadListPrec = liftReadListPrecDefault

4 3

Request for comment on new package
by David Feuer 09 Aug '19

09 Aug '19

I've put together a small package for lazifying record types. There's a "classy" version in Data.Lazify and a Generic-only version in Data.Lazify.Generic. A few examples are below. I'd love to hear comments on what looks good and what should be changed before I make the first release. As usual, names are the hardest part. Note especially that the operator ($~) is defined in *both* Data.Lazify and Data.Lazify.Generic, and that no operator corresponds to genericLazify. Hrmm mumble. lazify (1, 2) = (1, 2) lazify undefined = (_|_, _|_, _|_) lazify undefined = Sum (_|_, _|_, _|_) genericLazify (1,2) = (1,2) genericLazify undefined = (_|_, _|_, _|_) genericLazify (Sum (MyCon x y)) = ... oops, MyType isn't an instance of Lazifiable lazifyGeneric (1,2) = (1,2) lazifyGeneric undefined = (_|_, _|_, _|_) lazifyGeneric (Sum (MyCon x y)) = Sum (MyCon x y) Thanks in advance, David

4 6

Add instance Alternative (Either e)
by Dannyu NDos 08 Aug '19

08 Aug '19

instance Monoid e => Alternative (Either e) where empty = left mempty Left x <|> Left y = Left (x <> y) Left _ <|> y = y x <|> _ = x Leftmost Right is returned for sake of consistence with Semigroup instance.

2 1

Re: Add instance Monoid ((f :+: g) a)
by Dannyu NDos 06 Aug '19

06 Aug '19

Ah, sorry. (:+:) is not an Applicative. It's still possible to make instance Monoid: instance Semigroup (f a) => Semigroup ((f :+: g) a) where InL x <> InL y = InL (x <> y) InL _ <> y = y x <> _ = x instance Monoid (f a) => Monoid ((f :+: g) a) where mempty = InL mempty

1 1

Add instance Alternative (f :+: g)
by Dannyu NDos 06 Aug '19

06 Aug '19

instance Alternative f => Alternative (f :+: g) where empty = InL empty InL x <|> InL y = InL (x <|> y) InL _ <|> y = y x <|> _ = x This is analogous to the proposed Alternative Either instance.

1 0

foldrM definition
by Dannyu NDos 06 Aug '19

06 Aug '19

Wouldn't it be friendlier to list structures if foldl' was used instead of foldl?

2 1

Proposal: Remove Control.Monad.Instances
by David Feuer 02 Aug '19

02 Aug '19

The Control.Monad.Instances module in base has been deprecated since base-4.6.0, which was released in 2012. I believe the time has long since passed to actually remove the module, and I propose that we do so.

4 3

Is there a function \x -> (x, x) in standard libraries?
by Ignat Insarov 30 Jul '19

30 Jul '19

Hello. I wonder if there is a function like \x -> (x, x) in the standard libraries. I looked up in Hoogle. It gave me links: 1. https://hackage.haskell.org/package/utility-ht/docs/Data-Tuple-HT.html#v:do… 2. https://hackage.haskell.org/package/extra/docs/Data-Tuple-Extra.html#v:dupe 3. https://hackage.haskell.org/package/relude/docs/Relude-Extra-Tuple.html#v:d… None of these is to the standard library. I wonder if there is an intentional omission for some important reason? If not, I think this function should be added to Data.Tuple. I know some of the persons that make decisions here like Category theory, so I point out this function is mentioned in Categories for the Working Mathematician, as δ, the diagonal function, on page 3 (second edition), although set with angular brackets. Have a great day.

16 19