- Glasgow-haskell-users

Qualified names in TH?
by J. Garrett Morris 17 Mar '15

17 Mar '15

I'm trying to write some Template Haskell code that (among other things) manipulates IntSets. So, for example, I'd like a splice to generate a call to Data.IntSet.fromList. However, I'm not sure how IntSet will be imported in the target module. Is there a way to resolve the fully qualified name (or similar) to a TH Name, without having to know how it's imported in the splicing module? (The obvious approach---mkName "Data.IntSet.fromList"---seems not to work in GHC 7.8.) Thanks! /g -- The University of Edinburgh is a charitable body, registered in Scotland, with registration number SC005336.

3 2

[PATCH] generalize filterM, mapAndUnzipM, zipWithM, zipWithM_, replicateM, replicateM_
by M Farkas-Dyck 16 Mar '15

16 Mar '15

--- libraries/base/Control/Monad.hs | 37 ++++++++++++++++--------------------- 1 file changed, 16 insertions(+), 21 deletions(-) diff --git a/libraries/base/Control/Monad.hs b/libraries/base/Control/Monad.hs index 6fa4a07..02eabd1 100644 --- a/libraries/base/Control/Monad.hs +++ b/libraries/base/Control/Monad.hs @@ -75,9 +75,9 @@ module Control.Monad , (<$!>) ) where -import Data.Foldable ( Foldable, sequence_, msum, mapM_, foldlM, forM_ ) -import Data.Functor ( void ) -import Data.Traversable ( forM, mapM, sequence ) +import Data.Functor ( void, (<$>) ) +import Data.Foldable ( Foldable, sequence_, sequenceA_, msum, mapM_, foldlM, forM_ ) +import Data.Traversable ( forM, mapM, traverse, sequence, sequenceA ) import GHC.Base hiding ( mapM, sequence ) import GHC.List ( zipWith, unzip, replicate ) @@ -94,13 +94,8 @@ guard False = empty -- | This generalizes the list-based 'filter' function. {-# INLINE filterM #-} -filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a] -filterM p = foldr go (return []) - where - go x r = do - flg <- p x - ys <- r - return (if flg then x:ys else ys) +filterM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a] +filterM p = foldr (\ x -> liftA2 (\ flg -> if flg then (x:) else id) (p x)) (pure []) infixr 1 <=<, >=> @@ -125,19 +120,19 @@ forever a = let a' = a >> a' in a' -- | The 'mapAndUnzipM' function maps its first argument over a list, returning -- the result as a pair of lists. This function is mainly used with complicated -- data structures or a state-transforming monad. -mapAndUnzipM :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) +mapAndUnzipM :: (Applicative m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) {-# INLINE mapAndUnzipM #-} -mapAndUnzipM f xs = sequence (map f xs) >>= return . unzip +mapAndUnzipM f xs = unzip <$> traverse f xs --- | The 'zipWithM' function generalizes 'zipWith' to arbitrary monads. -zipWithM :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c] +-- | The 'zipWithM' function generalizes 'zipWith' to arbitrary applicative functors. +zipWithM :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m [c] {-# INLINE zipWithM #-} -zipWithM f xs ys = sequence (zipWith f xs ys) +zipWithM f xs ys = sequenceA (zipWith f xs ys) -- | 'zipWithM_' is the extension of 'zipWithM' which ignores the final result. -zipWithM_ :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m () +zipWithM_ :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m () {-# INLINE zipWithM_ #-} -zipWithM_ f xs ys = sequence_ (zipWith f xs ys) +zipWithM_ f xs ys = sequenceA_ (zipWith f xs ys) {- | The 'foldM' function is analogous to 'foldl', except that its result is encapsulated in a monad. Note that 'foldM' works from left-to-right over @@ -175,18 +170,18 @@ foldM_ f a xs = foldlM f a xs >> return () -- | @'replicateM' n act@ performs the action @n@ times, -- gathering the results. -replicateM :: (Monad m) => Int -> m a -> m [a] +replicateM :: (Applicative m) => Int -> m a -> m [a] {-# INLINEABLE replicateM #-} {-# SPECIALISE replicateM :: Int -> IO a -> IO [a] #-} {-# SPECIALISE replicateM :: Int -> Maybe a -> Maybe [a] #-} -replicateM n x = sequence (replicate n x) +replicateM n x = sequenceA (replicate n x) -- | Like 'replicateM', but discards the result. -replicateM_ :: (Monad m) => Int -> m a -> m () +replicateM_ :: (Applicative m) => Int -> m a -> m () {-# INLINEABLE replicateM_ #-} {-# SPECIALISE replicateM_ :: Int -> IO a -> IO () #-} {-# SPECIALISE replicateM_ :: Int -> Maybe a -> Maybe () #-} -replicateM_ n x = sequence_ (replicate n x) +replicateM_ n x = sequenceA_ (replicate n x) -- | The reverse of 'when'. unless :: (Applicative f) => Bool -> f () -> f () -- 2.3.1

1 0

-staticlib flag for building standalone static libraries producing very large libraries
by Sean Seefried 07 Mar '15

07 Mar '15

Hi all, Can anyone explain the following problem I'm having? I'm currently writing a game in Haskell. When I produce a plain old executable (for local testing) it's about 23M. However, when I create a static lib using the -staticlib flag it is 54M. Why the discrepancy? Sean

2 1

Record Puns/Wildcards
by Ben Franksen 25 Feb '15

25 Feb '15

I just noted that code like my_config = default_config {..} where name = "my project" description = "some longer text" gives me a syntax error, even if I have NamedFieldPuns and RecordWildCards extensions enabled. It seems that these extensions only work for record constructors and not for updating values. Is there a special reason puns/wildcards are not allowed in record updates? Cheers Ben -- "There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult." ― C.A.R. Hoare

2 2

Re: [Haskell-cafe] PowerPC variants (GHC 7.8.3)
by Carter Schonwald 25 Feb '15

25 Feb '15

Hey Jon, I do know that some of the GHC dev team is probably best equipped to answer your question, i'm cc'ing the ghc dev and users lists so they can jump in and help! -Carter On Wed, Feb 25, 2015 at 7:11 AM, Jon Schneider <haskell(a)jschneider.net> wrote: > Good morning, > > We have a product with an MPC8544E we might want to target. Also known as > PowerQUICC and e500v2. The ABI is gnuspe rather than gnueabi. > > I have built a powerpc---ghc cross compiler but the thing stopping "hello > world" is a SIGILL happening in StgCRun.c where the stfd and lfd > instructions are used to stash registers. The e500 has different > instructions but that cannot be dropped in trivially because of offset > encoding Commenting these out fixes "hello world" though this surely only > scratches the surface of what would need doing. > > I notice that whereas ARMv5, v6 and v7 appear to be catered for along with > various knobs and whistles there appears to be no such thing for PowerPC. > > Is anybody else out there working on this area ? > > Jon > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >

1 0

Re: Proposal: Turn on ScopedTypeVariables by default
by Roman Cheplyaka 24 Feb '15

24 Feb '15

On 24/02/15 14:46, Herbert Valerio Riedel wrote: > On 2015-02-23 at 18:45:20 +0100, David Feuer wrote: >> I know this will be controversial, because it can break (weird) code and >> because it's not Haskell 2010, but hey, you can't make brain salad without >> breaking a few heads. > > Are you suggesting enabling -XScopedTypeVariables for -XHaskell98 and > -XHaskell2010? or rather for the default when neither of those two modes > is explicitly requested? > > Just be warned though: this is somewhat of a trick-question... :-) Maybe in addition to -XHaskell98 and -XHaskell2010 there should also be -XGhcHaskell. ghc already deviates from the standard by default (e.g. -XNondecreasingIndentation). OTOH we probably don't want end up with -fglasgow-exts once again. Roman

1 0

Proposal: Turn on ScopedTypeVariables by default
by David Feuer 23 Feb '15

23 Feb '15

I know this will be controversial, because it can break (weird) code and because it's not Haskell 2010, but hey, you can't make brain salad without breaking a few heads. ScopedTypeVariables is just awesome for two fundamental reasons: 1. It lets you write type signatures for more things. 2. It lets you write more precise type signatures for many things. As a consequence of those two, 3. It helps you get much better error messages from the type checker. And for all that, 4. It's really easy to use. What do other people think?

5 4

ANNOUNCE: GHC 7.10.1 Release Candidate 2
by Austin Seipp 21 Feb '15

21 Feb '15

We are pleased to announce the second release candidate for GHC 7.10.1: https://downloads.haskell.org/~ghc/7.10.1-rc2/ This includes the source tarball and bindists for 64bit/32bit Linux and Windows. Binary builds for other platforms will be available shortly. (CentOS 6.5 binaries are not available at this time like they were for 7.8.x). These binaries and tarballs have an accompanying SHA256SUMS file signed by my GPG key id (0x3B58D86F). We plan to make the 7.10.1 release sometime in February of 2015. Please test as much as possible; bugs are much cheaper if we find them before the release! -- Regards, Austin Seipp, Haskell Consultant Well-Typed LLP, http://www.well-typed.com/

6 9

type checker plugin success depends on whether an expression is manually inlined
by adam vogt 20 Feb '15

20 Feb '15

Hello list, The following file compiles with my plugin. It makes a data family HList have role representational in a way that I believe is safe: https://github.com/aavogt/HListPlugin/blob/master/ex/Coerce.hs#L19 I expect the highlighted line to be acceptable. However, it seems that the plugin never sees anything from line 19, when I uncomment it. Is there something I can do to make that L19 work? Is this a known or intentional limitation of type checker plugins? Thanks, Adam

1 0

ApplicativeDo
by Thomas Bereknyei 19 Feb '15

19 Feb '15

There is a library for TH: http://hackage.haskell.org/package/applicative-quoters-0.1.0.8 (broken at the moment) There is a proposal at: https://ghc.haskell.org/trac/ghc/wiki/ApplicativeDo Now with AMP, is this worth revisiting? Why or why not? -Tom

2 2