- ghc-devs - Haskell.org

The BlockArguments extension has been added to Cabal
by Akio Takano 06 Feb '18

06 Feb '18

Dear GHC devs, The new `BlockArguments` extension has been added to the Cabal library. I'm sending out this notification because the Note [Adding a language extension] in compiler/main/DynFlags.hs asks me to do so. Regards, Takano Akio

3 2

RE: [commit: ghc] master: Hoopl.Collections: change right folds to strict left folds (2974b2b)
by Simon Peyton Jones 05 Feb '18

05 Feb '18

Hi Michael Thanks for pushing forward with Hoopl and other back-end things. Did this patch elicit any performance gains? Or what brought it to your attention? Do you have further plans for Hoopl and GHC's back end? Simon | -----Original Message----- | From: ghc-commits [mailto:ghc-commits-bounces@haskell.org] On Behalf | Of git(a)git.haskell.org | Sent: 03 February 2018 00:56 | To: ghc-commits(a)haskell.org | Subject: [commit: ghc] master: Hoopl.Collections: change right folds | to strict left folds (2974b2b) | | Repository : ssh://git@git.haskell.org/ghc | | On branch : master | Link : | https://na01.safelinks.protection.outlook.com/?url=http%3A%2F%2Fghc.ha | skell.org%2Ftrac%2Fghc%2Fchangeset%2F2974b2b873b4bad007c619c6e32706123 | a612428%2Fghc&data=02%7C01%7Csimonpj%40microsoft.com%7C19a7af179b224ee | 8b74708d56aa0fa00%7Cee3303d7fb734b0c8589bcd847f1c277%7C1%7C0%7C6365321 | 61979971135&sdata=muRQGh3GHuEirDVMUgTb0JKbBUkvqceymKFQTt9eAY0%3D&reser | ved=0 | | >--------------------------------------------------------------- | | commit 2974b2b873b4bad007c619c6e32706123a612428 | Author: Michal Terepeta <michal.terepeta(a)gmail.com> | Date: Thu Feb 1 00:30:22 2018 -0500 | | Hoopl.Collections: change right folds to strict left folds | | It seems that most uses of these folds should be strict left folds | (I could only find a single place that benefits from a right | fold). | So this removes the existing `setFold`/`mapFold`/`mapFoldWihKey` | replaces them with: | - `setFoldl`/`mapFoldl`/`mapFoldlWithKey` (strict left folds) | - `setFoldr`/`mapFoldr` (for the less common case where a right | fold | actually makes sense, e.g., `CmmProcPoint`) | | Signed-off-by: Michal Terepeta <michal.terepeta(a)gmail.com> | | Test Plan: ./validate | | Reviewers: bgamari, simonmar | | Reviewed By: bgamari | | Subscribers: rwbarton, thomie, carter, kavon | | Differential Revision: https://phabricator.haskell.org/D4356 | | | >--------------------------------------------------------------- | | 2974b2b873b4bad007c619c6e32706123a612428 | compiler/cmm/CmmCommonBlockElim.hs | 4 ++-- | compiler/cmm/CmmContFlowOpt.hs | 6 +++--- | compiler/cmm/CmmProcPoint.hs | 20 ++++++++++---------- | compiler/cmm/CmmUtils.hs | 6 +++--- | compiler/cmm/Hoopl/Collections.hs | 16 ++++++++++------ | compiler/cmm/Hoopl/Dataflow.hs | 8 ++++---- | compiler/cmm/Hoopl/Graph.hs | 6 +++--- | compiler/cmm/Hoopl/Label.hs | 9 ++++++--- | compiler/nativeGen/RegAlloc/Graph/Spill.hs | 9 ++++----- | 9 files changed, 45 insertions(+), 39 deletions(-) | | Diff suppressed because of size. To see it, use: | | git diff-tree --root --patch-with-stat --no-color --find-copies- | harder --ignore-space-at-eol --cc | 2974b2b873b4bad007c619c6e32706123a612428 | _______________________________________________ | ghc-commits mailing list | ghc-commits(a)haskell.org | https://na01.safelinks.protection.outlook.com/?url=http%3A%2F%2Fmail.h | askell.org%2Fcgi-bin%2Fmailman%2Flistinfo%2Fghc- | commits&data=02%7C01%7Csimonpj%40microsoft.com%7C19a7af179b224ee8b7470 | 8d56aa0fa00%7Cee3303d7fb734b0c8589bcd847f1c277%7C1%7C0%7C6365321619799 | 71135&sdata=hSeyqtbepopL%2FkSme3DPLOQQKf9WCLWsdVMh86tbx4o%3D&reserved= | 0

2 1

Re: [Haskell-cafe] rolling span and groupBy for lists
by Harendra Kumar 05 Feb '18

05 Feb '18

On 6 February 2018 at 00:33, Sergiu Ivanov <sivanov(a)colimite.fr> wrote: > Thus quoth Harendra Kumar on Mon Feb 05 2018 at 18:30 (+0100): > > Yes, Hayoo seems to be giving better results, I found more variants > having > > the behavior I want, it seems this variant is quite popular but still not > > in any standard libraries. > > > > Interestingly the problem of too many choices and no standard one that > can > > be discovered applies to search engines as well. In this case there are > > only two choices but still it is of the same nature. I knew about hayoo > but > > forgot to use it in this case. How much time should one spend on finding > a > > trivial function before giving up and making the choice to write their > own? > > I wish there was a standard, quick, good quality way of discovering what > to > > use. It seems the Haskell ecosystem DNA encourages more and more > > fragmentation rather than consolidation. I think the community/leaders > > should acknowledge this problem and work on making things better in the > > short/long run. > > A Single Liberal Unified Registry of Haskell Packages (SLUPR), an effort > in this direction, has been recently announced: > Unfortunately, in my opinion, SLURP is taking things exactly in the opposite direction. I was talking about the problem of choice above and SLURP is giving even more choices and therefore encouraging more fragmentation. We should have just one good choice to stop wasting time and energy finding the best choice among millions available. Everyone should focus on making that one choice better rather spending energy in creating their own alternatives. This is where the Haskell ecosystem philosophy differs, it provides many choices in all aspects, it may be good in some cases but not always. SLURP is a technology solution which exactly fits in the same DNA. Technology can help us achieve the tasks that we set out to do but technology cannot motivate and influence us in what we choose to do and therefore ti cannot make the community focus on one goal - that requires real people leadership. If we do not focus on one goal, even with the best technology we may not succeed. Just my 2 cents. -harendra > > > > -harendra > > > > On 5 February 2018 at 22:02, Sergiu Ivanov <sivanov(a)colimite.fr> wrote: > > > >> Hello Harendra, > >> > >> Thus quoth Harendra Kumar on Mon Feb 05 2018 at 16:43 (+0100): > >> > > >> > The irony is that theoretically you can find a Haskell package or > >> > implementation of whatever you can imagine but quite often it takes > more > >> > time to discover it than writing your own. > >> > >> Sometimes Hayoo! helps me out in such situations: > >> > >> http://hayoo.fh-wedel.de/?query=groupBy > >> > >> utility-ht shows up. > >> > >> -- > >> Sergiu > >> > > > -- > Sergiu >

2 1

rolling span and groupBy for lists
by Harendra Kumar 05 Feb '18

05 Feb '18

Hi, For a small problem, I was looking for a groupBy like function that groups based on a predicate on successive elements but I could not find one. I wrote these little functions for that purpose: -- | Like span, but with a predicate that compares two successive elements. The -- span ends when the two successive elements do not satisfy the predicate. rollingSpan :: (a -> a -> Bool) -> [a] -> ([a], [a]) rollingSpan _ xs@[] = (xs, xs) rollingSpan _ xs@[_] = (xs, []) rollingSpan p (x1:xs@(x2:_)) | p x1 x2 = let (ys, zs) = rollingSpan p xs in (x1 : ys, zs) | otherwise = ([x1], xs) -- | Like 'groupBy' but with a predicate that compares two successive elements. -- A group ends when two successive elements do not satisfy the predicate. rollingGroupBy :: (a -> a -> Bool) -> [a] -> [[a]] rollingGroupBy _ [] = [] rollingGroupBy cmp xs = let (ys, zs) = rollingSpan cmp xs in ys : rollingGroupBy cmp zs Are there any existing functions that serve this purpose or is there any simpler way to achieve such functionality? If not, where is the right place for these, if any. Can they be included in Data.List in base? Thanks, Harendra

4 6

Re: [Haskell-cafe] rolling span and groupBy for lists
by Harendra Kumar 05 Feb '18

05 Feb '18

Yes, Hayoo seems to be giving better results, I found more variants having the behavior I want, it seems this variant is quite popular but still not in any standard libraries. Interestingly the problem of too many choices and no standard one that can be discovered applies to search engines as well. In this case there are only two choices but still it is of the same nature. I knew about hayoo but forgot to use it in this case. How much time should one spend on finding a trivial function before giving up and making the choice to write their own? I wish there was a standard, quick, good quality way of discovering what to use. It seems the Haskell ecosystem DNA encourages more and more fragmentation rather than consolidation. I think the community/leaders should acknowledge this problem and work on making things better in the short/long run. -harendra On 5 February 2018 at 22:02, Sergiu Ivanov <sivanov(a)colimite.fr> wrote: > Hello Harendra, > > Thus quoth Harendra Kumar on Mon Feb 05 2018 at 16:43 (+0100): > > > > The irony is that theoretically you can find a Haskell package or > > implementation of whatever you can imagine but quite often it takes more > > time to discover it than writing your own. > > Sometimes Hayoo! helps me out in such situations: > > http://hayoo.fh-wedel.de/?query=groupBy > > utility-ht shows up. > > -- > Sergiu >

1 0

Re: rolling span and groupBy for lists
by Harendra Kumar 05 Feb '18

05 Feb '18

I was mainly asking if it makes sense to include these functions in base/Data.List. Since the base package is maintained and ships along with ghc, and the issues are also raised at ghc trac I thought this is the right list. I am copying to libraries(a)haskell.org as well. -harendra On 5 February 2018 at 09:53, David Feuer <david(a)well-typed.com> wrote: > This is the wrong list. You probably meant to email haskell-cafe or > perhaps libraries(a)haskell.org. > > > > David Feuer > Well-Typed, LLP > > -------- Original message -------- > From: Harendra Kumar <harendra.kumar(a)gmail.com> > Date: 2/4/18 10:50 PM (GMT-05:00) > To: ghc-devs(a)haskell.org > Subject: rolling span and groupBy for lists > > Hi, > > For a small problem, I was looking for a groupBy like function that groups > based on a predicate on successive elements but I could not find one. I > wrote these little functions for that purpose: > > -- | Like span, but with a predicate that compares two successive elements. > The > -- span ends when the two successive elements do not satisfy the predicate. > rollingSpan :: (a -> a -> Bool) -> [a] -> ([a], [a]) > rollingSpan _ xs@[] = (xs, xs) > rollingSpan _ xs@[_] = (xs, []) > rollingSpan p (x1:xs@(x2:_)) > | p x1 x2 = > let (ys, zs) = rollingSpan p xs > in (x1 : ys, zs) > | otherwise = ([x1], xs) > > -- | Like 'groupBy' but with a predicate that compares two successive > elements. > -- A group ends when two successive elements do not satisfy the predicate. > rollingGroupBy :: (a -> a -> Bool) -> [a] -> [[a]] > rollingGroupBy _ [] = [] > rollingGroupBy cmp xs = > let (ys, zs) = rollingSpan cmp xs > in ys : rollingGroupBy cmp zs > > Are there any existing functions that serve this purpose or is there any > simpler way to achieve such functionality? If not, where is the right place > for these, if any. Can they be included in Data.List in base? > > Thanks, > Harendra >

1 0

Nested CPR patch review
by Matthew Pickering 29 Jan '18

29 Jan '18

Hi all, I recently resurrected akio's nested cpr branch and put it on phabricator for review. https://phabricator.haskell.org/D4244 Sebastian has kindly been going over it and ironed out a few kinks in the last few days. He says now that he believes the patch is correct. Is there anything else which needs to be done before merging this patch? Simon, would you perhaps be able to give the patch a look over? Cheers, Matt

3 5

https://downloads.haskell.org/~ghc/master/
by Joachim Breitner 28 Jan '18

28 Jan '18

Hi, just curious: What is the status of https://downloads.haskell.org/~ghc/master/ where I would expect the documentation of GHC HEAD? It seems to be last updated in October, and also be missing the GHC API docs. Cheers, Joachim -- Joachim Breitner mail(a)joachim-breitner.de http://www.joachim-breitner.de/

2 1

GHC builds are broken
by David Feuer 27 Jan '18

27 Jan '18

The Linux build has been failing with a segfault. It looks to me as though this started with 0e022e56b130ab9d277965b794e70d8d3fb29533: Turn EvTerm (almost) into CoreExpr.

3 3

Re: [ANNOUNCE] GHC 8.4.1-alpha2 available
by Ryan Scott 25 Jan '18

25 Jan '18

Forgive me if I'm stating the obvious here, but the status of libraries like primitive, unordered-containers, and haskell-src-exts don't really have anything to do with GHC, since they're independent libraries that aren't shipped with GHC in any way. If you're impatient to use the Haskell library ecosystem with GHC 8.4.1, I highly encourage you to use a solution like head.hackage [1], as many library authors are not as much of early adopters as we are :) Ryan S. ----- [1] https://github.com/hvr/head.hackage

1 0