February 2018 - ghc-devs

Windows build broken -- help!
by Simon Peyton Jones 08 Feb '18

08 Feb '18

Aargh. Windows build is broken again. Log below. Help! Simon "inplace/bin/ghc-stage1.exe" -optc-fno-stack-protector -optc-Wall -optc-Werror -optc-Wall -optc-Wextra -optc-Wstrict-prototypes -optc-Wmissing-prototypes -optc-Wmissing-declarations -optc-Winline -optc-Waggregate-return -optc-Wpointer-arith -optc-Wmissing-noreturn -optc-Wnested-externs -optc-Wredundant-decls -optc-Wundef -optc-Iincludes -optc-Iincludes/dist -optc-Iincludes/dist-derivedconstants/header -optc-Iincludes/dist-ghcconstants/header -optc-Irts -optc-Irts/dist/build -optc-DCOMPILING_RTS -optc-fno-strict-aliasing -optc-fno-common -optc-Irts/dist/build/./autogen -optc-Wno-error=inline -optc-O2 -optc-fomit-frame-pointer -optc-g -optc-DRtsWay=\"rts_v\" -optc-DWINVER=0x06000100 -static -O0 -H64m -Wall -fllvm-fill-undef-with-garbage -Werror -Iincludes -Iincludes/dist -Iincludes/dist-derivedconstants/header -Iincludes/dist-ghcconstants/header -Irts -Irts/dist/build -DCOMPILING_RTS -this-unit-id rts -dcmm-lint -i -irts -irts/dist/build -Irts/dist/build -irts/dist/build/./autogen -Irts/dist/build/./autogen -O2 -Wcpp-undef -Wnoncanonical-monad-instances -c rts/StgPrimFloat.c -o rts/dist/build/StgPrimFloat.o rts\Schedule.c:274:14: error: error: unknown conversion type character 'l' in format [-Werror=format=] barf("sched_state: %" FMT_Word, sched_state); ^~~~~~~~~~~~~~~~ | 274 | barf("sched_state: %" FMT_Word, sched_state); | ^ In file included from C:/code/HEAD-1/inplace/mingw/x86_64-w64-mingw32/include/stdio.h:1036:0, from includes/rts/Flags.h:16, from includes/Rts.h:191, from rts\Schedule.c:11:0: error: C:/code/HEAD-1/inplace/mingw/x86_64-w64-mingw32/include/_mingw_print_pop.h:86:18: note: format string is defined here #define PRIu64 "llu" ^ rts\Schedule.c:274:14: error: error: too many arguments for format [-Werror=format-extra-args] barf("sched_state: %" FMT_Word, sched_state); ^~~~~~~~~~~~~~~~ | 274 | barf("sched_state: %" FMT_Word, sched_state); | ^ cc1.exe: all warnings being treated as errors `gcc.exe' failed in phase `C Compiler'. (Exit code: 1) "inplace/bin/ghc-stage1.exe" -optc-fno-stack-protector -optc-Wall -optc-Werror -optc-Wall -optc-Wextra -optc-Wstrict-prototypes -optc-Wmissing-prototypes -optc-Wmissing-declarations -optc-Winline -optc-Waggregate-return -optc-Wpointer-arith -optc-Wmissing-noreturn -optc-Wnested-externs -optc-Wredundant-decls -optc-Wundef -optc-Iincludes -optc-Iincludes/dist -optc-Iincludes/dist-derivedconstants/header -optc-Iincludes/dist-ghcconstants/header -optc-Irts -optc-Irts/dist/build -optc-DCOMPILING_RTS -optc-fno-strict-aliasing -optc-fno-common -optc-Irts/dist/build/./autogen -optc-Wno-error=inline -optc-O2 -optc-fomit-frame-pointer -optc-g -optc-DRtsWay=\"rts_v\" -optc-DWINVER=0x06000100 -static -O0 -H64m -Wall -fllvm-fill-undef-with-garbage -Werror -Iincludes -Iincludes/dist -Iincludes/dist-derivedconstants/header -Iincludes/dist-ghcconstants/header -Irts -Irts/dist/build -DCOMPILING_RTS -this-unit-id rts -dcmm-lint -i -irts -irts/dist/build -Irts/dist/build -irts/dist/build/./autogen -Irts/dist/build/./autogen -O2 -Wcpp-undef -Wnoncanonical-monad-instances -c rts/Profiling.c -o rts/dist/build/Profiling.o make[1]: *** [rts/ghc.mk:295: rts/dist/build/Schedule.o] Error 1 make[1]: *** Waiting for unfinished jobs.... make: *** [Makefile:127: all] Error 2 /c/code/HEAD-1$

3 4

package01e failure
by Simon Peyton Jones 07 Feb '18

07 Feb '18

I'm getting this test failure, presumably because of a version bump in containers. I think this is a clean build from scratch. Could someone have forgotten to update a test file? Simon =====> package01e(normal) 1 of 1 [0, 0, 0] cd "./package01e.run" && "/5playpen/simonpj/HEAD-5/inplace/test spaces/ghc-stage2" -c package01e.hs -dcore-lint -dcmm-lint -no-user-package-db -rtsopts -fno-warn-missed-specialisations -fshow-warning-groups -fdiagnostics-color=never -fno-diagnostics-show-caret -dno-debug-output -hide-all-packages -XNoImplicitPrelude -package "containers (Data.Map as Map, Data.Set)" Actual stderr output differs from expected: diff -uw "./package01e.run/package01e.stderr.normalised" "./package01e.run/package01e.comp.stderr.normalised" --- ./package01e.run/package01e.stderr.normalised 2018-02-07 09:52:44.562487065 +0000 +++ ./package01e.run/package01e.comp.stderr.normalised 2018-02-07 09:52:44.562487065 +0000 @@ -2,9 +2,11 @@ package01e.hs:2:1: Could not find module 'Data.Map' It is a member of the hidden package 'containers-0.5.11.0'. + It is a member of the hidden package 'containers-0.5.10.2'. Use -v to see a list of the files searched for. package01e.hs:3:1: Could not find module 'Data.IntMap' It is a member of the hidden package 'containers-0.5.11.0'. + It is a member of the hidden package 'containers-0.5.10.2'. Use -v to see a list of the files searched for. *** unexpected failure for package01e(normal)

2 1

Strict unlifted types
by David Feuer 07 Feb '18

07 Feb '18

Sometimes there's an awkward expressive tension between saying that a type is *unboxed* and saying that it is *strict* in a field. For example, I can write data SMaybe a = SNothing | SJust !a or I can write type Maybe# a = (# (# #) | a #) but there doesn't seem to be a way to simultaneously get both unboxed and strict. I'm wondering if it might make sense to add a type to serve the purpose Strict# :: Type -> TYPE 'UnliftedRep mkStrict# :: a -> Strict# a -- force the argument getStrict# :: Strict# a -> a -- do nothing, but know the result is in WHNF Then one could write, for example, type SMaybe# a = (# (# #) | Strict# a #) at which point SMaybe is *precisely* isomorphic to the alternative representation data SMaybe' a = SMaybe' (SMaybe# a) David

2 1

[ANNOUNCE] GHC 8.4.1-alpha3 available
by Ben Gamari 06 Feb '18

06 Feb '18

The GHC development team is pleased to announce the third and likely last alpha release leading up to GHC 8.4.1. The usual release artifacts are available from https://downloads.haskell.org/~ghc/8.4.1-alpha3 Due to user demand we now offer a binary distribution for 64-bit Fedora 27, which links against ncurses6. This is in contrast to the Debian 8 distribution, which links against ncurses5. Users of newer distributions (Fedora 27, Debian Sid) should use this new Fedora 27 distribution. Also due to user demand we have reintroduced compatibility with GCC 4.4, which earlier alphas had dropped due to #14244. Note that this release is still affected by #14675, wherein the compiler will segmentation fault when built with some Ubuntu toolchains. We are actively working to identify the cause and hope that this will be resolved before the final release. === Notes on release scheduling === The 8.4.1 release marks the first release where GHC will be adhering to its new, higher-cadence release schedule [1]. Under this new scheme, major releases will be made in 6-month intervals with interstitial minor releases as necessary. In order to minimize the likelihood of schedule slippage and to ensure adequate testing, each major release will be preceded by a number of regular alpha releases. We will begin issuing these releases roughly three months before the final date of the major release and will issue roughly one every two weeks during this period. This high release cadence will allow us to quickly get fixes into users' hands and more quickly identify potential issues. As always, do let us know if you encounter any trouble in the course of testing. Thanks for your help! Cheers, - Ben [1] https://ghc.haskell.org/trac/ghc/blog/2017-release-schedule

1 0

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 04 Feb '18

04 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