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

Simon Peyton-Jones simonpj at microsoft.com
Thu May 30 23:33:43 CEST 2013


I've pushed a fix.

Simon

-----Original Message-----
From: Simon Peyton-Jones 
Sent: 30 May 2013 17:37
To: Ian Lynagh; ghc-devs at haskell.org
Subject: RE: Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

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.d
| yn_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.$fDTVecto
| r_$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.$WMDVecto
| r{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.$fDT
| Int8{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.$WMDVecto
| r{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.$fDTVecto
| r_$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.Ga
| ng{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.$WMDV
| ector{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