April 2019 - Libraries

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

Incremental Regex Parsing with Fixed Strings
by Andrew Martin 12 Sep '19

12 Sep '19

Greetings, In Dan Piponi's blog post Fast Incremental Regular Expression Matching with Monoids [1], he outlines a way to take advantage of fingertrees to perform increment regex matching. In his article, the regular expression (more accurately, its equivalent DFA) is fixed, and the strings we are matching on are modified incrementally. What I'm interested in is the opposite: What if the regular expression is modified incrementally and the string we are testing is static? Thinking about this, it seems to run into problems immediately. Typically, to evaluate a regular expression, I would convert it to a NFA (and then maybe to a DFA). But there is no way to do incremental graph modification on the resulting graphs. (Or is there?). And even if there were a way, it seems unclear how one would go about exploiting its incremental nature. To provide an example, consider the following regex and sample string: Regex: Lost (dog|cat) loo for home Sample: Lost dog looking for home In the regex, I'm currently in the middle of typing "looking", so it doesn't match the sample string. But large parts of it do. So when I update the regex by typing "k", I'd like to be able to not redo this work. Maybe there's a certain subset of regex that's amenable to this kind of incremental evaluation. Maybe not. If anyone has any additional insights or can point me to any research, I would appreciate it greatly. Thanks. [1] http://blog.sigfpe.com/2009/01/fast-incremental-regular-expression.html -- -Andrew Thaddeus Martin

5 6

Add NonEmptyMap and NonEmptySet to containers
by John Cotton Ericson 29 Apr '19

29 Apr '19

In https://github.com/haskell/containers/issues/608 I proposed adding non-empty variants of Map and Set, analogous to Data.List.NonEmpty for List, to containers. semigroupoids demonstrates the many uses and structure of non-empty containers in general, and libraries such as https://github.com/mstksg/nonempty-containers and https://github.com/andrewthad/non-empty-containers demonstrate the interest in non-empty maps and sets in particular. My favorite use-case is that they're needed to "curry" containers: for example, |Map (k0, k1) v| is isomorphic not to |Map k0 (Map k1 v)| but to |Map k0 (NonEmptyMap k1 v)|. I like this use-case because it comes from the containers themselves. Importantly, there's no good way to do this outside of containers; doing so leads to imbalancing / extra indirection, or massive code duplication. If one wraps the container was an extra value like Data.List.NonEmpty, one's left with an unavoidable extra indirection/imbalance. One can rectify this by copying and modifying the implementation of containers, but that's hardly maintainable; even as though the algorithms are the same, enough lines are touched that merging upstream containers is nigh impossible. On the other hand, the non-empty containers can be elegantly and sufficiently implemented alongside their originals by taking the Bin constructor and breaking it out into it's own type, mutually recursive with the original. This avoids the indirection/imbalancing and code duplication problems: the algorithms work exactly as before creating the same trees (remember the UNPACK), and no code duplicated since the functions become mutually recursive matching the types. To briefly summarize the thread: 1. I proposed the issue after performing this same refactor on the dependent-map package: https://github.com/obsidiansystems/dependent-map/tree/non-empty, a fork of containers. 2. I made https://github.com/haskell/containers/pull/616 which just changes the types, to make sure UNPACK preserved the importance. 3. https://gist.github.com/Ericson2314/58709d0d99e0c0e83ad266701cd71841 the benchmarks showed rather than degrading performance, PR 616 actually /improved/ it. If there is preliminary consensus, I'll make a second PR on top which generalizes the functions like on my dependent-map branch. Thanks, John

13 31

Proposal: Laws for mtl classes
by Li-yao Xia 24 Apr '19

24 Apr '19

Hello Libraries, I am looking for feedback and discussion about the laws I am proposing in the following pull requests (to save you the click, I will copy the laws at the end of this email): - MonadState and MonadReader: https://github.com/haskell/mtl/pull/61 - MonadError: https://github.com/haskell/mtl/pull/62 Laws for the other classes will be proposed in the future. Indeed, you may be surprised to learn that these classes have never had documented laws, in spite of the often touted importance of laws in the Haskell community: https://github.com/haskell/mtl/issues/5 There is a vague consensus that "classes should have laws", but with very little guidance as to how to design those laws. My approach so far mostly consists of "think very hard about all possible configurations, relying on my experience in equational reasoning". There are papers (some mentioned in the Github issue) discussing such laws, they are useful as a starting point, but most of them focus on MonadState or Alternative, and when MonadReader does appear, local is missing from the picture. More crucially, beyond saying "it's the only thing I can think of", it seems difficult to critically evaluate a given set of laws. Some subtle variations can be quite challenging to compare, see for example this post about two definitions of idempotency: https://duplode.github.io/posts/idempotent-applicatives-parametricity-and-a… Suggestions and additional references in this area are more than welcome. As part of figuring things out, I wrote those mtl laws as QuickCheck tests, in a style inspired by the checkers library: https://github.com/Lysxia/checkers-mtl (still unreleased) Further bikeshedding is likely to take place, and feel free to ask questions to clarify anything. - Could these laws be made simpler? - Are there additional laws that are expected to hold? - Are there reasonable instances that break those laws? For instance, I decided to include laws that turn get and ask into noops if their results are ignored, but could it make sense to allow them to have side effects? I have plans to publish more detailed write-ups about those proposed laws (as blogposts or as part of the documentation), but even having documented laws at all seems better than nothing now, if only to serve as a basis for more concrete discussions. Li-yao --- Class definitions and proposed laws reproduced below. -- MonadReader class Monad m => MonadReader r m | m -> r where {-# MINIMAL (ask | reader), local #-} ask :: m r local :: (r -> r) -> m a -> m a reader :: (r -> a) -> m a {- m <*> ask = ask <**> m ask >> pure x = pure x ask >>= \s1 -> ask >>= \s2 -> k s1 s2 = ask >>= \s -> k s s local f ask = f <$> ask local g . local f = local (g . f) -- local is a monad morphism from m to m local f (pure x) = pure x local f (a >>= k) = local f a >>= \x -> local f (k x) ask = reader id -} -- MonadState class Monad m => MonadState s m | m -> s where {-# MINIMAL state | get, put #-} get :: m s put :: s -> m () state :: (s -> (a, s)) -> m a {- get >>= put = pure () put s >> get = put s >> pure s put s1 >> put s2 = put s2 get >> pure x = pure x get >>= \s1 -> get >>= \s2 -> k s1 s2 = get >>= \s -> k s s get = state (\s -> (s, s)) put s = state (\_ -> ((), s)) -} -- MonadError class (Monad m) => MonadError e m | m -> e where throwError :: e -> m a catchError :: m a -> (e -> m a) -> m a {- catchError (throwError e) h = h e catchError (pure a) h = pure a catchError (catchError m k) h = catchError m (\e -> catchError (k e) h) catchError (m >>= k) h = tryError m >>= either h k -- tryError :: MonadError e m => m a -> m (Either e a) catchError m throwError = m throwError e >>= k = throwError e -}

2 2

Add a Functor instance to Kleisli
by Dmitriy Kovanikov 18 Apr '19

18 Apr '19

Hello everyone! I would like to propose to add a `Functor` instance to the `Kleisli` data type from the `Control.Arrow` module. The instance can look like this: instance Functor m => Functor (Kleisli m a) where fmap :: (b -> c) -> Kleisli m a b -> Kleisli m a c fmap f (Kleisli h) = Kleisli (fmap f . h) {-# INLINE fmap #-} (<$) :: c -> Kleisli m a b -> Kleisli m a c c <$ Kleisli h = Kleisli (\a -> c <$ h a) {-# INLINE (<$) #-} Having this instance would be really helpful in improving the `profunctors` package by adding QuantifiedConstraints to it. See more details in the discussion below: https://github.com/ekmett/profunctors/pull/70#discussion_r267648958 Thanks, Dmitrii Kovanikov

4 3

Proposal: Add Data.Monoid.mwhen :: Monoid m => Bool -> m -> m
by James Ashwell 11 Apr '19

11 Apr '19

This would mimic the behaviour of Control.Monad.when for monoids rather than applicatives. mwhen :: Monoid m => Bool -> m -> m mwhen b a | b = a | otherwise = mempty -- Examples: when :: Applicative f => Bool -> f () -> f () when b = getAp . mwhen b . Ap -- mwhen b = getConst . when b . Const guard :: Alternative f => Bool -> f () guard b = getAlt (mwhen b (pure ())) applyIf :: Bool -> (a -> a) -> (a -> a) applyIf b = appEndo . mwhen b . Endo -- Using Monoid m => Monoid (a -> m) -- mwhen b f x = if b then f x else mempty = mwhen b (f x) -- mwhen b f x y = if b then f x y else mempty = mwhen b (f x y) -- etc -- mwhen b x <> y = if b then x <> y else y

5 5

Add missing Monad/Traversable instances to tuples
by Fumiaki Kinoshita 09 Apr '19

09 Apr '19

I submitted https://gitlab.haskell.org/ghc/ghc/merge_requests/644 but it might be still controversial. I'd like to get more opinions again. Here's the list of proposed instances: Foldable ((,,) a b) Foldable ((,,,) a b c) Traversable ((,,) a b) Traversable ((,,,) a b c) Functor ((,,) a b) (Monoid a, Monoid b) => Applicative ((,,) a b) (Monoid a, Monoid b) => Monad ((,,) a b) Functor ((,,,) a b c) (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) The absence of Traversable instances for tuples feels quite inconsistent given that there are Bitraversable instances already.

22 29

Re: Adding more instances to Kleisli: Generic, Monad, etc
by Ryan Scott 08 Apr '19

08 Apr '19

+1 from me, although I find it somewhat curious that this proposes adding a Generic instance, but not a Generic1 instance. Perhaps that should be included in the patch as well? Ryan S.

2 1

Adding more instances to Kleisli: Generic, Monad, etc
by Fumiaki Kinoshita 08 Apr '19

08 Apr '19

This is another part of https://gitlab.haskell.org/ghc/ghc/merge_requests/644, which is presumably much less controversial: Generic (Kleisli m a b) Functor m => Functor (Kleisli m a) Applicative m => Applicative (Kleisli m a) Alternative m => Alternative (Kleisli m a) Monad m => Monad (Kleisli m a) (Alternative m, Monad m) => MonadPlus (Kleisli m a)

5 7