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

30 May 2013

      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_$cnewMD{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_$cnewMD{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

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

Ian Lynagh