- Libraries - Haskell.org

Proposal: parametrize tree stem container type in containers
by M Farkas-Dyck 19 Mar '15

19 Mar '15

A few years ago I uploaded the package generic-tree to Hackage (before I knew the customary version scheme, sorry about that) which has trees parametrized over stem container type: data Tree v a = Node a (v (Tree v a)) As this is a functional superset of the containers tree, I think it appropriate to include in containers, which I hereby propose. Ultimately, if this is accepted, I would like to define the list-specialized tree in terms of this.

2 1

Proposed significant breaking changes to Win32
by Yitzchak Gale 18 Mar '15

18 Mar '15

There are some discussions going on in this issue: https://github.com/haskell/win32/issues/24 with proposals for extensive breaking changes to the Win32 library. Well over 100 functions would be involved. These changes would finally fix many long outstanding defects in the API, some of which make it impossible to use important Win32 functions in the way originally intended. I would generally support these proposals (after having seen that Neil supports them). But does anyone have any estimate of how much breakage it would cause on Hackage, or in the Windows builds of GHC? Thanks, Yitz

2 1

Expand the Data.Set API
by David Feuer 17 Mar '15

17 Mar '15

There are a few rather conspicuously missing features: 1. A way to take the intersection of a list of sets. This shouldn't really be a big deal, and it already exists for unions, but the intersection version should probably sort the sets by size before folding, or otherwise try to do something smart. 2. A way to insert an element if an == one is not already present (insert replaces an existing one with a new one). Currently, as far as I can tell, this can only be done using either if e `member` s then s else insert e s which potentially descends the tree twice for no reason or s `union` singleton e which is documented as being O(|s|+1), although I wouldn't be shocked if the documentation were too pessimistic in this case. 3. A way to delete an element and simultaneously find out whether it was in the set. David Feuer

8 9

zipWithA, zipWithA_, mapAndUnzipA, filterA, replicateA, replicateA_
by M Farkas-Dyck 17 Mar '15

17 Mar '15

Analogs of monadic functions, which likely ought to be in base as part of AMP. I send no patch yet, for I not know which way to do the Data.Traversable <-> Control.Applicative cyclic import. -- | 'filterA' generalizes the list-based 'filter' function. {-# INLINE filterA #-} filterA :: (Applicative p) => (a -> p Bool) -> [a] -> p [a] filterA p = foldr (\ x -> liftA2 (\ flg -> bool flg (x:) id) (p x)) (pure []) where bool True x = const x bool False _ = id -- | 'mapAndUnzipA' maps its first argument over a list, returning the result as a pair of lists. {-# INLINE mapAndUnzipA #-} mapAndUnzipA :: (Applicative p) => (a -> p (b, c)) -> [a] -> p ([b], [c]) mapAndUnzipA f xs = unzip <$> traverse f xs -- | 'zipWithA' generalizes 'zipWith' to arbitrary applicative functors. {-# INLINE zipWithA #-} zipWithA :: (Applicative p) => (a -> b -> p c) -> [a] -> [b] -> p [c] zipWithA f x y = sequenceA (zipWith f x y) -- | 'zipWithA_' is the extension of 'zipWithA' which ignores the final result. {-# INLINE zipWithA_ #-} zipWithA_ :: (Applicative p) => (a -> b -> p c) -> [a] -> [b] -> p () zipWithA_ f x y = sequenceA_ (zipWith f x y) -- | @'replicateA' n x@ does @x@ @n@ times, gathering the results. {-# INLINEABLE replicateA #-} {-# SPECIALIZE replicateA :: Int -> IO a -> IO [a] #-} {-# SPECIALIZE replicateA :: Int -> Maybe a -> Maybe [a] #-} replicateA :: (Applicative p) => Int -> p a -> p [a] replicateA n x = sequenceA (replicate n x) -- | 'replicateA_' is like 'replicateA', but discards the result. {-# INLINEABLE replicateA_ #-} {-# SPECIALIZE replicateA_ :: Int -> IO a -> IO () #-} {-# SPECIALIZE replicateA_ :: Int -> Maybe a -> Maybe () #-} replicateA_ :: (Applicative p) => Int -> p a -> p () replicateA_ n x = sequenceA_ (replicate n x)

7 8

Generalizing map?
by Fumiaki Kinoshita 15 Mar '15

15 Mar '15

A dozen of functions like concat, foldr, mapM, have been generalized through BBP. Then, why do we leave `map` just for lists? Obviously `map` can be generalized, so map :: Functor f => (a -> b) -> f a -> f b map = fmap The current definition of `map` looks too special to be a special case of mapM (map f = runIdentity . mapM (Identity . f)).

16 18

Proposal: Add (<$>) to Prelude as part of the AMP in GHC 7.10-RC3
by Edward Kmett 10 Mar '15

10 Mar '15

We have a couple of weeks until the third release candidate for GHC 7.10 goes out the door. Along the way with the last couple of release candidates folks have found some problems with the way we implemented the AMP. [1][2] Most notably, we failed to include (<$>) in the Prelude, so the standard idiom of foo <$> bar <*> baz <*> quux doesn't work out of the box! I'd like to include (<$>) in the Prelude in RC3. I'd also like to invite discussion about whether folks believe we should include (<$) out of the box. (<$) has been a member of Functor for a long time, which is only visible if you import it from Data.Functor or bring in Control.Applicative. There is an idiom that you use (<*) and (<$) to point to the parts of the structure that you want to keep the answers from when building longer such Applicative chains. Discussion Period: 2 weeks Thank you, -Edward Kmett [1] http://www.reddit.com/r/haskell/comments/2wzixa/shouldnt_be_in_prelude/ [2] https://plus.google.com/115504368969270249241/posts/URzeDWd7qMp

39 50

Add MonadError () Maybe
by Phil Scott 09 Mar '15

09 Mar '15

With Maybe being isomorphic to Either (), can we have the instance MonadError () Maybe? I'm interested in the MonadError class, and write generic code against it, and would like it to work with Maybe.

3 2

ANNOUNCE: fgl 5.5.1.0
by Ivan Lazar Miljenovic 09 Mar '15

09 Mar '15

I'm pleased to announce that - after being pestered about it for the past few months ;-) - I've released a new version of the Functional Graph Library that should* now be compatible with GHC 7.10. fgl is now developed on GitHub: https://github.com/haskell/fgl * In that I can't test it on my own machines -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com http://IvanMiljenovic.wordpress.com

1 0

Missing instances for Eq1 (Const a), Ord1 (Const a), Show1 (Const a), Ord1 (Const a)
by Edward Kmett 08 Mar '15

08 Mar '15

I was looking at switching a chunk of my code over from prelude-extras to transformers 0.5, but the classes in http://hackage.haskell.org/package/transformers-0.4.2.0/docs/Data-Functor-C… are currently missing instances for Control.Applicative.Const. =/ -Edward

2 1

Re: ApplicativeZip
by Oleg Grenrus 08 Mar '15

08 Mar '15

After thinking for a while (and looking onto MonadZip [] instance), I realised that: `MonadZip []` is the same as `Applicative ZIpList`, not `Applicative []` I guess that answers my question. Also Information preservation law: liftM (const ()) ma = liftM (const ()) mb excludes the default implementation of munzip for non-deterministic computations, as the information is “multiplied". The naturality law follows from Applicative laws. — After some thinking (and re-reading the "Monadic zipping (used for monad comprehensions)” comment in the documentation), this is obvious. But I’ll try to make a documentation improvement patch, so no-one have to wonder this that much again. - Oleg > On 06 Mar 2015, at 10:30, David Feuer <david.feuer(a)gmail.com> wrote: > > It was already discussed, I think, but I don't remember the conclusion! > > On Mar 6, 2015 3:27 AM, "Oleg Grenrus" <oleg.grenrus(a)iki.fi> wrote: > After Edward Kmett mentioned that we should add MonadZip to Data.Monoid instances, that got me thinking about: > > Why we don’t have ApplicativeZip? > > class Applicative f => ApplicativeZip f where > {-# MINIMAL azip | azipWith #-} > azip :: m a -> m b -> m (a,b) > azip = azipWith (,) > > -- This is `liftA2` but can be done more efficiently for some instances (is it true?) > azipWith :: (a -> b -> c) -> m a -> m b -> m c > azipWith f = azip (uncurry f) > > aunzip :: m (a,b) -> (m a, m b) > aunzip mab = (fst <$> mab, liftM <$> mab) > > and > > class (Monad m, ApplicativeZip m) => MonadZip m where > mzip :: m a -> m b -> m (a,b) > mzip = azip > > mzipWith :: (a -> b -> c) -> m a -> m b -> m c > mzipWith = azipWith > > munzip :: m (a,b) -> (m a, m b) > munzip = aunzip > > IMHO that should been done during AMP-reform, sorry if this topic is already discussed. > > - Oleg > > _______________________________________________ > Libraries mailing list > Libraries(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >

1 0