Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Simon Peyton-Jones simonpj at microsoft.com
Thu May 30 18:36:35 CEST 2013


I can reproduce it.  It's very likely my fault.  Stay tuned.  But I have to go to London tomorrow.  Apols

| -----Original Message-----
| From: ghc-devs-bounces at haskell.org [mailto:ghc-devs-bounces at haskell.org]
| On Behalf Of Ian Lynagh
| Sent: 30 May 2013 15:22
| To: ghc-devs at haskell.org
| Subject: Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]
| 
| 
| Hi all,
| 
| The validate build is failing for me with the below. Does anyone know
| what's up please?
| 
| 
| Thanks
| Ian
| 
| 
| ===--- building phase 0
| make -r --no-print-directory -f ghc.mk phase=0 phase_0_builds
| make[1]: Nothing to be done for `phase_0_builds'.
| ===--- building phase 1
| make -r --no-print-directory -f ghc.mk phase=1 phase_1_builds
| ===--- building final phase
| make -r --no-print-directory -f ghc.mk phase=final all
| "inplace/bin/ghc-stage2" -hisuf hi -osuf  o -hcsuf hc -static  -H32m -O -Werror -
| Wall -H64m -O0    -package-name dph-prim-par-0.8.0.1 -hide-all-packages -i -
| ilibraries/dph/dph-prim-par/. -ilibraries/dph/dph-prim-par/dist-install/build -
| ilibraries/dph/dph-prim-par/dist-install/build/autogen -Ilibraries/dph/dph-prim-
| par/dist-install/build -Ilibraries/dph/dph-prim-par/dist-install/build/autogen -
| Ilibraries/dph/dph-prim-par/.    -optP-include -optPlibraries/dph/dph-prim-
| par/dist-install/build/autogen/cabal_macros.h -package base-4.7.0.0 -package
| dph-base-0.8.0.1 -package dph-prim-interface-0.8.0.1 -package dph-prim-seq-
| 0.8.0.1 -package old-time-1.1.0.1 -package random-1.0.1.1 -package vector-
| 0.9.1 -Odph -funbox-strict-fields -fcpr-off -Wall -XHaskell98 -XTypeFamilies -
| XGADTs -XRankNTypes -XBangPatterns -XMagicHash -XUnboxedTuples -
| XTypeOperators -XFlexibleInstances -XFlexibleContexts -O2 -O -dcore-lint -fno-
| warn-deprecated-flags  -no-user-package-db -rtsopts -Wwarn     -odir
| libraries/dph/dph-prim-par/dist-install/build -hidir libraries/dph/dph-prim-
| par/dist-install/build -stubdir libraries/dph/dph-prim-par/dist-install/build  -
| dynamic-too -c libraries/dph/dph-prim-
| par/./Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.hs -o
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o -dyno
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.dyn_o
| Var/Type length mismatch:
|     []
|     [s{tv a15I} [tv]]
| ghc-stage2: panic! (the 'impossible' happened)
|   (GHC version 7.7.20130530 for x86_64-unknown-linux):
| 	Iface Lint failure
|     In interface for dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector
|     Unfolding of dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnew
| MD{v rS}
|       <no location info>: Warning:
|           In the expression: base:Control.Monad.liftM2{v rC} [gid]
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                     s3{tv a1Zk} [tv]
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv]))
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv])
|                                     s3{tv a1Zk} [tv])
|                                @ (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])
|                                (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]] @ s3{tv a1Zk}
| [tv])
|                                (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
| [gid[DataConWrapper]]
|                                   @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv])
|                                ((dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
| [gid]
|                                    @ s3{tv a1Zk} [tv] g{v a1Zl} [lid])
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk}
| [tv]>)
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                 s3{tv a1Zk} [tv])))
|                                ((\ (s4{v a21s} [lid]
|                                       :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv])
| ->
|                                    case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v
| rw} [gid]
|                                           @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                           @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                              -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                           ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                           (ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]] 0)
|                                           (case g{v a1Zl} [lid]
|                                            {ghc-prim:GHC.Types.Int{(w) tc 3J}}
|                                            of (wild{v a27g} [lid]
|                                                  :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                            { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v
| a27R} [lid]
| 
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
| 
| (ds1{v a27S} [lid]
| 
| :: [base:GHC.MVar.MVar{tc r1Q2}
| 
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
| 
| (ds2{v a27T} [lid]
| 
| :: base:GHC.MVar.MVar{tc r1Q2}
| 
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                            ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                              dt{v a27R} [lid]
|                                            })
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (wild{v a27V} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                    { ghc-prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|                                                                         :: ghc-prim:GHC.Prim.Int#{(w) tc
| 3G}) ->
|                                    case ghc-prim:GHC.Prim.newArray#{(w) v 920}
| [gid[PrimOp]]
|                                           @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                a4{tv a1Zi} [tv])
|                                           @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                           n#{v a280} [lid]
|                                           (base:GHC.Err.error{(w) v 05} [gid]
|                                              @ (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                   a4{tv a1Zi} [tv])
|                                              (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|                                                 "MDist (Vector a) - uninitalised"#))
|                                           (s4{v a21s} [lid]
|                                            `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                      (Sym
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                            <s3{tv a1Zk} [tv]>))
|                                                    :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         s3{tv a1Zk} [tv]
|                                                         ~#
|                                                       ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                            (base:GHC.ST.ST{tc rE}
|                                                               s3{tv a1Zk} [tv]))))
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (ds1{v a282} [lid]
|                                          :: (# ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])),
|                                                ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                  (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                     a4{tv a1Zi} [tv]) #))
|                                    { (# (ipv{v a284} [lid]
|                                            :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE}
|                                                       s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|                                                                               :: ghc-
| prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                                                       (base:GHC.ST.ST{tc rE}
|                                                                                          s3{tv a1Zk} [tv]))
|                                                                                    (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                       a4{tv a1Zi} [tv])) #) ->
|                                    (# ipv{v a284} [lid]
|                                       `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                    <s3{tv a1Zk} [tv]>)
|                                               :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                       (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                    ~#
|                                                  ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    s3{tv a1Zk} [tv]),
|                                       vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
| [gid[DataCon]]
|                                         @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                              (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                         @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                              a4{tv a1Zi} [tv])
|                                         0
|                                         n#{v a280} [lid]
|                                         ipv1{v a285} [lid] #)
|                                    }
|                                    })
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (Sym
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                       <s3{tv a1Zk} [tv]>))
|                                                 <vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                    a4{tv a1Zi} [tv]>))
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 s3{tv a1Zk} [tv]
|                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))))
|           Argument value doesn't match argument type:
|           Fun type:
|               (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                  ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|                -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                     s3{tv a1Zk} [tv]
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                     s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                       s3{tv a1Zk} [tv]
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv]))
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv])
|                       s3{tv a1Zk} [tv])
|           Arg type:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|               -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|               -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|           Arg:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
| [gid[DataConWrapper]]
|                 @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv]
|     dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnew
| MD{v rS} = \ (@ a4{tv a1Zi} [tv])
|                                                                                                            ($dUnbox{v
| a1Zj} [lid]
|                                                                                                               :: vector-
| 0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW}
|                                                                                                                    a4{tv
| a1Zi} [tv])
|                                                                                                            (@ s3{tv
| a1Zk} [tv])
|                                                                                                            (g{v a1Zl}
| [lid]
|                                                                                                               :: dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
| ->
| 
| base:Control.Monad.liftM2{v rC} [gid]
|                                                                                                              @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|                                                                                                                   ghc-
| prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                   s3{tv
| a1Zk} [tv])
|                                                                                                              @ (vector-
| 0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                                                                                                   s3{tv
| a1Zk} [tv]
|                                                                                                                   (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      a4{tv
| a1Zi} [tv]))
|                                                                                                              @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|                                                                                                                   (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      a4{tv
| a1Zi} [tv])
|                                                                                                                   s3{tv
| a1Zk} [tv])
|                                                                                                              @
| (base:GHC.ST.ST{tc rE}
|                                                                                                                   s3{tv
| a1Zk} [tv])
| 
| (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]]
|                                                                                                                 @ s3{tv
| a1Zk} [tv])
|                                                                                                              (dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v
| rz} [gid[DataConWrapper]]
|                                                                                                                 @ a4{tv
| a1Zi} [tv]
|                                                                                                                 @ s3{tv
| a1Zk} [tv])
|                                                                                                              ((dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v
| ry} [gid]
|                                                                                                                  @ s3{tv
| a1Zk} [tv]
|                                                                                                                  g{v a1Zl}
| [lid])
|                                                                                                               `cast` (Sym
| 
| (base:GHC.ST.NTCo:ST{tc rx}[0]
| 
| <s3{tv a1Zk} [tv]>
| 
| <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
| 
| ghc-prim:GHC.Types.Int{(w) tc 3J}
| 
| s3{tv a1Zk} [tv]>)
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
| 
| s3{tv a1Zk} [tv]
| 
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
| 
| ghc-prim:GHC.Types.Int{(w) tc 3J}
| 
| s3{tv a1Zk} [tv])
|                                                                                                                            ~#
| 
| base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]
| 
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
| 
| ghc-prim:GHC.Types.Int{(w) tc 3J}
| 
| s3{tv a1Zk} [tv])))
|                                                                                                              ((\ (s4{v
| a21s} [lid]
|                                                                                                                     :: ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                          s3{tv
| a1Zk} [tv]) ->
|                                                                                                                  case
| vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw} [gid]
|                                                                                                                         @
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                         @
| (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                            ->
| ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                         ghc-
| prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                                                                                                         (ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            0)
|                                                                                                                         (case
| g{v a1Zl} [lid]
|                                                                                                                          {ghc-
| prim:GHC.Types.Int{(w) tc 3J}}
|                                                                                                                          of
| (wild{v a27g} [lid]
|                                                                                                                                ::
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                                                                                                          {
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v
| a27R} [lid]
| 
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
| 
| (ds1{v a27S} [lid]
| 
| :: [base:GHC.MVar.MVar{tc r1Q2}
| 
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
| 
| (ds2{v a27T} [lid]
| 
| :: base:GHC.MVar.MVar{tc r1Q2}
| 
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                                                                                                          ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            dt{v
| a27R} [lid]
|                                                                                                                          })
|                                                                                                                  {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        s3{tv
| a1Zk} [tv],
|                                                                                                                      vector-
| 0.9.1:Data.Vector.Mutable.MVector{tc rq}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
| 
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  of (wild{v
| a27V} [lid]
|                                                                                                                        :: ghc-
| prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                  { ghc-
| prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
| 
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G}) ->
|                                                                                                                  case ghc-
| prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
|                                                                                                                         @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv])
|                                                                                                                         @
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
|                                                                                                                         n#{v
| a280} [lid]
| 
| (base:GHC.Err.error{(w) v 05} [gid]
|                                                                                                                            @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv])
| 
| (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
| 
| "MDist (Vector a) - uninitalised"#))
|                                                                                                                         (s4{v
| a21s} [lid]
| 
| `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| (Sym
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
| 
| <s3{tv a1Zk} [tv]>))
| 
| :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| s3{tv a1Zk} [tv]
| 
| ~#
| 
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))))
|                                                                                                                  {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        s3{tv
| a1Zk} [tv],
|                                                                                                                      vector-
| 0.9.1:Data.Vector.Mutable.MVector{tc rq}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
| 
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  of (ds1{v
| a282} [lid]
|                                                                                                                        :: (#
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv])),
| 
| ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
| 
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv]) #))
|                                                                                                                  { (# (ipv{v
| a284} [lid]
|                                                                                                                          ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
| 
| :: ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
| 
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv])) #) ->
|                                                                                                                  (# ipv{v
| a284} [lid]
|                                                                                                                     `cast`
| (ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
| 
| <s3{tv a1Zk} [tv]>)
|                                                                                                                             ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
| 
| ~#
| 
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
| 
| s3{tv a1Zk} [tv]),
|                                                                                                                     vector-
| 0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
|                                                                                                                       @
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
|                                                                                                                       @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv])
|                                                                                                                       0
|                                                                                                                       n#{v
| a280} [lid]
|                                                                                                                       ipv1{v
| a285} [lid] #)
|                                                                                                                  }
|                                                                                                                  })
|                                                                                                               `cast` (Sym
| 
| (base:GHC.ST.NTCo:ST{tc rx}[0]
| 
| <s3{tv a1Zk} [tv]>
| 
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
| 
| (Sym
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
| 
| <s3{tv a1Zk} [tv]>))
| 
| <vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv]>))
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
| 
| s3{tv a1Zk} [tv]
| 
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
| 
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
| 
| (base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]))
| 
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv]))
|                                                                                                                            ~#
| 
| base:GHC.ST.ST{tc rE}
| 
| s3{tv a1Zk} [tv]
| 
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
| 
| s3{tv a1Zk} [tv]
| 
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
| 
| a4{tv a1Zi} [tv]))))
|     Iface expr = \ @ a4
|                    $dUnbox :: vector-0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW} a4
|                    @ s3
|                    g :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF} ->
|                  base:Control.Monad.liftM2{v rC}
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           ghc-prim:GHC.Types.Int{(w) tc 3J} s3)
|                    @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                           s3 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4))
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4) s3)
|                    @ (base:GHC.ST.ST{tc rE} s3)
|                    (base:GHC.ST.$fMonadST{v rA} @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
|                       @ a4
|                       @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
|                       @ s3
|                       g)
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (Refl
|                                   (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                        ghc-prim:GHC.Types.Int{(w) tc 3J} s3))))
|                    (\ s4 :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3 ->
|                     case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw}
|                            @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                            @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                               -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                            ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv}
|                            (ghc-prim:GHC.Types.I#{(w) v 6d} 0)
|                            (case g of wild { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} dt
| ds1 ds2 ->
|                             ghc-prim:GHC.Types.I#{(w) v 6d}
|                               dt }) of wild { ghc-prim:GHC.Types.I#{(w) d 6c} n# ->
|                     case ghc-prim:GHC.Prim.newArray#{(w) v 920}
|                            @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                            @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                   (base:GHC.ST.ST{tc rE} s3))
|                            n#
|                            (base:GHC.Err.error{(w) v 05}
|                               @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                               (ghc-prim:GHC.CString.unpackCString#{v 0k}
|                                  "MDist (Vector a) - uninitalised"#))
|                            s4
|                              `cast`
|                            (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                 (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                           (Refl
|                                                s3)))) of ds1 { ghc-prim:GHC.Prim.(#,#){(w) d 84}
| ipv ipv1 ->
|                     (# ipv
|                          `cast`
|                        (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                             (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                  (Refl s3))),
|                        vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
|                          @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                 (base:GHC.ST.ST{tc rE} s3))
|                          @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                          0
|                          n#
|                          ipv1 #) } })
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                   (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                             (Refl s3)))
|                                   (Refl (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU} a4)))))
| 
| Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug
| 
| make[1]: *** [libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o] Error
| 1
| make: *** [all] Error 2
| 
| 
| _______________________________________________
| ghc-devs mailing list
| ghc-devs at haskell.org
| http://www.haskell.org/mailman/listinfo/ghc-devs



More information about the ghc-devs mailing list