packages feed

llvm-extra 0.13.0.1 → 0.13.1

raw patch · 12 files changed

+325/−68 lines, 12 filesdep +doctest-libdep ~non-emptydep ~taggedPVP ok

version bump matches the API change (PVP)

Dependencies added: doctest-lib

Dependency ranges changed: non-empty, tagged

API changes (from Hackage documentation)

+ LLVM.Extra.Nice.Value.Vector: replicateSegmented :: (Positive n, Select a) => NVVector n Bool -> T a -> NVVector n a -> CodeGenFunction r (NVVector n a)
+ LLVM.Extra.Nice.Vector: cumulate1Segmented :: (Positive n, Additive a, Select a) => T n Bool -> T n a -> CodeGenFunction r (T n a)
+ LLVM.Extra.Nice.Vector: cumulateSegmented :: (Positive n, Additive a, Select a) => T n Bool -> T a -> T n a -> CodeGenFunction r (T a, T n a)
+ LLVM.Extra.Nice.Vector: replicateSegmented :: (Positive n, Select a) => T n Bool -> T a -> T n a -> CodeGenFunction r (T n a)

Files

Makefile view
@@ -1,11 +1,5 @@ .PHONY:	sharedobj -testbuild:-	runhaskell Setup.lhs configure --user -fbuildExamples --enable-tests-	runhaskell Setup.lhs build-#	runhaskell Setup.lhs haddock-	./dist/build/llvm-extra-test/llvm-extra-test- llvmversion = 2.6  sharedobj:	libLLVM.so
llvm-extra.cabal view
@@ -1,6 +1,6 @@ Cabal-Version:  2.2 Name:           llvm-extra-Version:        0.13.0.1+Version:        0.13.1 License:        BSD-3-Clause License-File:   LICENSE Author:         Henning Thielemann <haskell@henning-thielemann.de>@@ -63,7 +63,7 @@   default:     False  Source-Repository this-  Tag:         0.13.0.1+  Tag:         0.13.1   Type:        darcs   Location:    http://code.haskell.org/~thielema/llvm-extra/ @@ -84,7 +84,7 @@     storable-enum >=0.0 && <0.1,     bool8 >=0.0 && <0.1,     transformers >=0.1.1 && <0.7,-    tagged >=0.7 && <0.9,+    tagged >=0.7 && <0.10,     utility-ht >=0.0.15 && <0.1,     prelude-compat >=0.0 && <0.0.1,     base-orphans >= 0.5 && <1,@@ -174,12 +174,14 @@   Type: exitcode-stdio-1.0   Build-Depends:     doctest-exitcode-stdio >=0.0 && <0.1,+    doctest-lib >=0.1.1 && <0.2,     QuickCheck >=2.11 && <3,     private,     llvm-extra,     llvm-tf,     tfp,     storable-record,+    non-empty,     utility-ht >=0.0.1 && <0.1,     transformers,     base >=3 && <5@@ -188,6 +190,10 @@   Hs-Source-Dirs: test   Main-Is: Main.hs   Other-Modules:+    DocTest.LLVM.Extra.Nice.Value.Vector+    DocTest.Main     Test.Storable     Test.Vector+    Test.Run+    Test.RunNice     LLVM.Extra.VectorAlt
src/LLVM/Extra/Arithmetic.hs view
@@ -268,7 +268,9 @@    sin, cos, exp, log :: a -> CodeGenFunction r a    pow :: a -> a -> CodeGenFunction r a -instance (IsFloating a, SoV.TranscendentalConstant a) => Transcendental (Value a) where+instance+   (IsFloating a, SoV.TranscendentalConstant a) =>+      Transcendental (Value a) where    pi = return $ value SoV.constPi    sin = Intrinsic.call1 "sin"    cos = Intrinsic.call1 "cos"
src/LLVM/Extra/Nice/Value/Vector.hs view
@@ -14,6 +14,7 @@     extract, insert,    replicate,+   replicateSegmented,    iterate,    dissect,    dissect1,@@ -48,6 +49,24 @@ import Prelude (Float, Double, Bool, fmap, (.))  +{- $setup+>>> import Test.RunNice (sharedRun, run)+>>> import qualified LLVM.Extra.Nice.Value.Vector as Vector+>>> import qualified LLVM.Extra.Nice.Value as NV+>>> import qualified LLVM.Core as LLVM+>>> import Type.Data.Num.Decimal (D4, D8)+>>> import qualified Data.Foldable as Fold+>>> import qualified Data.List as List+>>> import qualified Data.NonEmpty as NonEmpty+>>> import Control.Applicative (liftA2)+>>> import Data.Int (Int32)+>>> import Test.QuickCheck ((===))+>>>+>>> type N = D8+>>> type VectorN = LLVM.Vector N+-}++ cons ::    (TypeNum.Positive n, NiceVector.C a) =>    LLVM.Vector n a -> NVVector n a@@ -126,11 +145,45 @@ insert k a = Inst.liftNiceValueM (NiceVector.insert k a)  +{- |+>>> run Vector.replicate 42 :: LLVM.Vector D4 Int32+Vector [42,42,42,42]+-} replicate ::    (TypeNum.Positive n, NiceVector.C a) =>    NiceValue.T a -> LLVM.CodeGenFunction r (NVVector n a) replicate = fmap Inst.toNiceValue . NiceVector.replicate +{- |+>>> run (NV.uncurry3 Vector.replicateSegmented) (LLVM.consVector False False True False False True False False, 8, LLVM.consVector 7 6 5 4 3 2 1 0) :: LLVM.Vector D8 Int32+Vector [8,8,5,5,5,2,2,2]++prop> :{+   sharedRun (NV.uncurry3 Vector.replicateSegmented) $ \replicateSegmented ->+   \bs x xs ->+      NonEmpty.tail+         (NonEmpty.scanl (\lastX (b,xi) -> if b then xi else lastX)+            x (liftA2 (,) bs xs))+      ===+      replicateSegmented (bs, x, xs :: VectorN Int32)+:}+-}+replicateSegmented ::+   (TypeNum.Positive n, NiceVector.Select a) =>+   NVVector n Bool -> NiceValue.T a -> NVVector n a ->+   LLVM.CodeGenFunction r (NVVector n a)+replicateSegmented b0 a x0 =+   Inst.liftNiceValueM2 (\b x -> NiceVector.replicateSegmented b a x) b0 x0++{- |+prop> :{+   sharedRun (NV.uncurry (\d -> Vector.iterate (NV.add d))) $ \iter ->+   \d x ->+      List.take 8 (List.iterate (d+) x)+      ===+      Fold.toList (iter (d,x) :: LLVM.Vector D8 Int32)+:}+-} iterate ::    (TypeNum.Positive n, NiceVector.C a) =>    (NiceValue.T a -> LLVM.CodeGenFunction r (NiceValue.T a)) ->
src/LLVM/Extra/Nice/Vector.hs view
@@ -10,6 +10,7 @@    map,    zip, zip3, unzip, unzip3,    replicate,+   replicateSegmented,    iterate,    take,    takeRev,@@ -18,6 +19,8 @@    dotProduct,    cumulate,    cumulate1,+   cumulateSegmented,+   cumulate1Segmented,     lift1, @@ -96,7 +99,7 @@ import Data.Function (flip, (.), ($), ) import Data.Tuple (snd, ) import Data.Maybe (maybe, )-import Data.Ord ((<), )+import Data.Ord ((<), (<=)) import Data.Word (Word8, Word16, Word32, Word64, Word) import Data.Int (Int8, Int16, Int32, Int64, ) import Data.Bool8 (Bool8)@@ -555,8 +558,7 @@    (TypeNum.Positive n, C a) =>    [NiceValue.T a] -> CodeGenFunction r (T n a) assemble =-   foldlM (\v (k,x) -> insert (valueOf k) x v) undef .-   List.zip [0..]+   foldlM (\v (k,x) -> insert (valueOf k) x v) undef . List.zip [0..]  dissect ::    (TypeNum.Positive n, C a) =>@@ -671,6 +673,21 @@       (List.take (size v0) [0..])  +replicateSegmented ::+   (TypeNum.Positive n, Select a) =>+   T n Bool -> NiceValue.T a -> T n a ->+   CodeGenFunction r (T n a)+replicateSegmented b a x =+   fmap snd $+   foldlM+      (\(bi,xi) k ->+         liftA2 (,)+            (or bi =<< shiftUpMultiZero k bi)+            (select bi xi =<< shiftUpMulti a k xi))+      (b,x)+      (List.takeWhile (<= size x) $ List.iterate (2*) 1)++ sum ::    (TypeNum.Positive n, Additive a) =>    T n a -> CodeGenFunction r (NiceValue.T a)@@ -707,6 +724,30 @@       (List.takeWhile (< size x) $ List.iterate (2*) 1)  +cumulateSegmented ::+   (TypeNum.Positive n, Additive a, Select a) =>+   T n Bool -> NiceValue.T a -> T n a ->+   CodeGenFunction r (NiceValue.T a, T n a)+cumulateSegmented b a0 x0 = do+   (a1,x1) <- shiftUp a0 x0+   x2 <- cumulate1Segmented b =<< select b zero x1+   a2 <- A.add a1 =<< last x2+   return (a2,x2)++cumulate1Segmented ::+   (TypeNum.Positive n, Additive a, Select a) =>+   T n Bool -> T n a -> CodeGenFunction r (T n a)+cumulate1Segmented b x =+   fmap snd $+   foldlM+      (\(bi,xi) k ->+         liftA2 (,)+            (or bi =<< shiftUpMultiZero k bi)+            (add xi =<< select bi zero =<< shiftUpMultiZero k xi))+      (b,x)+      (List.takeWhile (< size x) $ List.iterate (2*) 1)++ -- * re-ordering of elements  constCyclicVector ::@@ -810,29 +851,49 @@       (List.takeWhile (< sizev) $ List.iterate (1+) n)       (NonEmptyC.repeat sizev) +shiftUpMultiGen ::+   (TypeNum.Positive n, C a) =>+   T n a -> Int -> T n a -> LLVM.CodeGenFunction r (T n a)+shiftUpMultiGen a n v =+   shuffle (shiftUpMultiIndices n (size v)) v a++shiftDownMultiGen ::+   (TypeNum.Positive n, C a) =>+   T n a -> Int -> T n a -> LLVM.CodeGenFunction r (T n a)+shiftDownMultiGen a n v =+   shuffle (shiftDownMultiIndices n (size v)) v a++shiftUpMulti ::+   (TypeNum.Positive n, C a) =>+   NiceValue.T a -> Int -> T n a -> LLVM.CodeGenFunction r (T n a)+shiftUpMulti a n v =+   shuffle (shiftUpMultiIndices n (size v)) v =<< replicate a++_shiftDownMulti ::+   (TypeNum.Positive n, C a) =>+   NiceValue.T a -> Int -> T n a -> LLVM.CodeGenFunction r (T n a)+_shiftDownMulti a n v =+   shuffle (shiftDownMultiIndices n (size v)) v =<< replicate a+ shiftUpMultiZero ::    (TypeNum.Positive n, C a) =>    Int -> T n a -> LLVM.CodeGenFunction r (T n a)-shiftUpMultiZero n v =-   shuffle (shiftUpMultiIndices n (size v)) v zero+shiftUpMultiZero = shiftUpMultiGen zero  shiftDownMultiZero ::    (TypeNum.Positive n, C a) =>    Int -> T n a -> LLVM.CodeGenFunction r (T n a)-shiftDownMultiZero n v =-   shuffle (shiftDownMultiIndices n (size v)) v zero+shiftDownMultiZero = shiftDownMultiGen zero  shiftUpMultiUndef ::    (TypeNum.Positive n, C a) =>    Int -> T n a -> LLVM.CodeGenFunction r (T n a)-shiftUpMultiUndef n v =-   shuffle (shiftUpMultiIndices n (size v)) v undef+shiftUpMultiUndef = shiftUpMultiGen undef  shiftDownMultiUndef ::    (TypeNum.Positive n, C a) =>    Int -> T n a -> LLVM.CodeGenFunction r (T n a)-shiftDownMultiUndef n v =-   shuffle (shiftDownMultiIndices n (size v)) v undef+shiftDownMultiUndef = shiftDownMultiGen undef   -- * method implementations based on Traversable
+ test/DocTest/LLVM/Extra/Nice/Value/Vector.hs view
@@ -0,0 +1,64 @@+-- Do not edit! Automatically created with doctest-extract from src/LLVM/Extra/Nice/Value/Vector.hs+{-# LINE 52 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}++module DocTest.LLVM.Extra.Nice.Value.Vector where++import Test.DocTest.Base+import qualified Test.DocTest.Driver as DocTest++{-# LINE 53 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+import     Test.RunNice (sharedRun, run)+import     qualified LLVM.Extra.Nice.Value.Vector as Vector+import     qualified LLVM.Extra.Nice.Value as NV+import     qualified LLVM.Core as LLVM+import     Type.Data.Num.Decimal (D4, D8)+import     qualified Data.Foldable as Fold+import     qualified Data.List as List+import     qualified Data.NonEmpty as NonEmpty+import     Control.Applicative (liftA2)+import     Data.Int (Int32)+import     Test.QuickCheck ((===))++type     N = D8+type     VectorN = LLVM.Vector N++test :: DocTest.T ()+test = do+ DocTest.printPrefix "LLVM.Extra.Nice.Value.Vector:149: "+{-# LINE 149 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+ DocTest.example(+{-# LINE 149 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+    run Vector.replicate 42 :: LLVM.Vector D4 Int32+  )+  [ExpectedLine [LineChunk "Vector [42,42,42,42]"]]+ DocTest.printPrefix "LLVM.Extra.Nice.Value.Vector:158: "+{-# LINE 158 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+ DocTest.example(+{-# LINE 158 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+    run (NV.uncurry3 Vector.replicateSegmented) (LLVM.consVector False False True False False True False False, 8, LLVM.consVector 7 6 5 4 3 2 1 0) :: LLVM.Vector D8 Int32+  )+  [ExpectedLine [LineChunk "Vector [8,8,5,5,5,2,2,2]"]]+ DocTest.printPrefix "LLVM.Extra.Nice.Value.Vector:161: "+{-# LINE 161 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+ DocTest.property(+{-# LINE 161 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+        +   sharedRun (NV.uncurry3 Vector.replicateSegmented) $ \replicateSegmented ->+   \bs x xs ->+      NonEmpty.tail+         (NonEmpty.scanl (\lastX (b,xi) -> if b then xi else lastX)+            x (liftA2 (,) bs xs))+      ===+      replicateSegmented (bs, x, xs :: VectorN Int32)+  )+ DocTest.printPrefix "LLVM.Extra.Nice.Value.Vector:179: "+{-# LINE 179 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+ DocTest.property(+{-# LINE 179 "src/LLVM/Extra/Nice/Value/Vector.hs" #-}+        +   sharedRun (NV.uncurry (\d -> Vector.iterate (NV.add d))) $ \iter ->+   \d x ->+      List.take 8 (List.iterate (d+) x)+      ===+      Fold.toList (iter (d,x) :: LLVM.Vector D8 Int32)+  )
+ test/DocTest/Main.hs view
@@ -0,0 +1,10 @@+-- Do not edit! Automatically created with doctest-extract.+module DocTest.Main where++import qualified DocTest.LLVM.Extra.Nice.Value.Vector++import qualified Test.DocTest.Driver as DocTest++main :: DocTest.T ()+main = do+    DocTest.LLVM.Extra.Nice.Value.Vector.test
test/LLVM/Extra/VectorAlt.hs view
@@ -156,7 +156,7 @@        LLVM.IsPrimitive a, LLVM.IsPrimitive (Mask a),        LLVM.IsInteger (Mask a)) =>          Maskable a where-   type Mask a :: *+   type Mask a  instance Maskable Int8   where type Mask Int8   = Int8 instance Maskable Int16  where type Mask Int16  = Int16
test/Main.hs view
@@ -1,5 +1,6 @@ module Main where +import qualified DocTest.Main as DocTest import qualified Test.Storable as Storable import qualified Test.Vector as Vector @@ -16,10 +17,12 @@ main = do    LLVM.initializeNativeTarget -   DocTest.run $ mapM_-      (\(msg,prop) -> do-         DocTest.printPrefix (msg++": ")-         DocTest.property =<< liftIO prop) $-      map (mapFst ("Storable."++)) Storable.tests ++-      map (mapFst ("Vector."++)) Vector.tests ++-      []+   DocTest.run $ do+      DocTest.main+      mapM_+         (\(msg,prop) -> do+            DocTest.printPrefix (msg++": ")+            DocTest.property =<< liftIO prop) $+         map (mapFst ("Storable."++)) Storable.tests +++         map (mapFst ("Vector."++)) Vector.tests +++         []
+ test/Test/Run.hs view
@@ -0,0 +1,38 @@+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE TypeFamilies #-}+module Test.Run where++import qualified LLVM.Extra.Memory as Memory+import qualified LLVM.ExecutionEngine as EE+import qualified LLVM.Core as LLVM++import Foreign.Ptr (FunPtr)+++type Importer func = FunPtr func -> func++generateFunction ::+   EE.ExecutionFunction f =>+   Importer f -> LLVM.CodeGenModule (LLVM.Function f) -> IO f+generateFunction imprt code = do+   m <- LLVM.newModule+   fn <- do+      func <- LLVM.defineModule m $ LLVM.setTarget LLVM.hostTriple >> code+      EE.runEngineAccessWithModule m $ EE.getExecutionFunction imprt func+   LLVM.writeBitcodeToFile "test-vector.bc" m+   return fn+++foreign import ccall safe "dynamic" derefTestCasePtr ::+   Importer (LLVM.Ptr inp -> LLVM.Ptr out -> IO ())++modul ::+   (Memory.C linp, Memory.Struct linp ~ minp, LLVM.IsType minp,+    Memory.C lout, Memory.Struct lout ~ mout, LLVM.IsType mout) =>+   (linp -> LLVM.CodeGenFunction () lout) ->+   LLVM.CodeGenModule (LLVM.Function (LLVM.Ptr minp -> LLVM.Ptr mout -> IO ()))+modul codegen =+   LLVM.createFunction LLVM.ExternalLinkage $ \xPtr yPtr -> do+      flip Memory.store yPtr =<< codegen =<< Memory.load xPtr+      LLVM.ret ()
+ test/Test/RunNice.hs view
@@ -0,0 +1,40 @@+module Test.RunNice where++import qualified Test.QuickCheck as QC++import Test.Run (generateFunction, derefTestCasePtr, modul)++import qualified LLVM.Extra.Nice.Value.Marshal as Marshal+import qualified LLVM.Extra.Nice.Value as NV+import qualified LLVM.Core as LLVM++import System.IO.Unsafe (unsafePerformIO)+++sharedRun ::+   (QC.Testable prop, Marshal.C a, Marshal.C b) =>+   (NV.T a -> LLVM.CodeGenFunction () (NV.T b)) ->+   ((a -> b) -> prop) -> QC.Property+sharedRun f prop =+   QC.idempotentIOProperty $ do+      code <- runIO f+      return $ QC.forAllBlind (return code) prop++run ::+   (Marshal.C a, Marshal.C b) =>+   (NV.T a -> LLVM.CodeGenFunction () (NV.T b)) ->+   a -> b+run = unsafePerformIO . runIO++runIO ::+   (Marshal.C a, Marshal.C b) =>+   (NV.T a -> LLVM.CodeGenFunction () (NV.T b)) ->+   IO (a -> b)+runIO f = do+   funIO <- generateFunction derefTestCasePtr $ modul f++   return $ \a ->+      unsafePerformIO $+      Marshal.alloca $ \bPtr ->+      Marshal.with a $ \aPtr ->+      funIO aPtr bPtr >> Marshal.peek bPtr
test/Test/Vector.hs view
@@ -4,21 +4,19 @@ {-# LANGUAGE FlexibleContexts #-} module Test.Vector where +import Test.Run (generateFunction, derefTestCasePtr, modul)+ import qualified LLVM.Extra.ScalarOrVectorPrivate as SoVPriv import qualified LLVM.Extra.ScalarOrVector as SoV import qualified LLVM.Extra.VectorAlt as VectorAlt import qualified LLVM.Extra.Vector as Vector-import qualified LLVM.Extra.Memory as Memory import qualified LLVM.Extra.Marshal as Marshal import qualified LLVM.Extra.Tuple as Tuple-import qualified LLVM.ExecutionEngine as EE import qualified LLVM.Core as LLVM  import qualified Type.Data.Num.Decimal as TypeNum import Type.Base.Proxy (Proxy(Proxy)) -import Foreign.Ptr (FunPtr)- import qualified Data.Traversable as Trav import qualified Data.Foldable as Fold import qualified Data.Bits as Bits@@ -40,40 +38,22 @@ type V4Int32 = V4 Int32 type V4Float = V4 Float -type Importer func = FunPtr func -> func -generateFunction ::-   EE.ExecutionFunction f =>-   Importer f -> LLVM.CodeGenModule (LLVM.Function f) -> IO f-generateFunction imprt code = do-   m <- LLVM.newModule-   fn <- do-      func <- LLVM.defineModule m $ LLVM.setTarget LLVM.hostTriple >> code-      EE.runEngineAccessWithModule m $ EE.getExecutionFunction imprt func-   LLVM.writeBitcodeToFile "test-vector.bc" m-   return fn-+data Equality a = Equality a a -foreign import ccall safe "dynamic" derefTestCasePtr ::-   Importer (LLVM.Ptr inp -> LLVM.Ptr out -> IO ())+infix 4 =!= -modul ::-   (Memory.C linp, Memory.Struct linp ~ minp, LLVM.IsType minp,-    Memory.C lout, Memory.Struct lout ~ mout, LLVM.IsType mout) =>-   (linp -> LLVM.CodeGenFunction () lout) ->-   LLVM.CodeGenModule (LLVM.Function (LLVM.Ptr minp -> LLVM.Ptr mout -> IO ()))-modul codegen =-   LLVM.createFunction LLVM.ExternalLinkage $ \xPtr yPtr -> do-      flip Memory.store yPtr =<< codegen =<< Memory.load xPtr-      LLVM.ret ()+(=!=) :: a -> a -> Equality a+(=!=) = Equality  run ::    (Marshal.C inp, Marshal.Struct inp ~ minp, LLVM.IsType minp,     Marshal.C out, Marshal.Struct out ~ mout, LLVM.IsType mout,     Tuple.ValueOf inp ~ linp, Tuple.ValueOf out ~ lout) =>    (Show inp, QC.Arbitrary inp) =>+   (Show a, Eq a) =>    (linp -> LLVM.CodeGenFunction () lout) ->-   (inp -> out -> Bool) ->+   (inp -> out -> Equality a) ->    IO QC.Property run codegen predicate = do    funIO <- generateFunction derefTestCasePtr $ modul codegen@@ -85,7 +65,11 @@                Marshal.alloca $ \yPtr -> do                   funIO xPtr yPtr                   Marshal.peek yPtr-         QCMon.assert $ predicate x y+         case predicate x y of+            Equality a b -> do+               QCMon.monitor $ QC.counterexample $ show a+               QCMon.monitor $ QC.counterexample $ show b+               QCMon.assert $ a==b   vec4 :: V4 a -> V4 a@@ -97,14 +81,14 @@    (Int32 -> Int32) ->    IO QC.Property unop codegen fun =-   run codegen (\x y -> fmap fun (vec4 x) == vec4 y)+   run codegen (\x y -> fmap fun (vec4 x) =!= vec4 y)  unopFloat ::    (LLVM.Value V4Float -> LLVM.CodeGenFunction () (LLVM.Value V4Float)) ->    (Float -> Float) ->    IO QC.Property unopFloat codegen fun =-   run codegen (\x y -> fmap fun (vec4 x) == vec4 y)+   run codegen (\x y -> fmap fun (vec4 x) =!= vec4 y)   binop ::@@ -116,7 +100,7 @@    IO QC.Property binop codegen fun =    run (uncurry codegen)-      (\(x,y) z -> liftA2 fun (vec4 x) (vec4 y)  ==  vec4 z)+      (\(x,y) z -> liftA2 fun (vec4 x) (vec4 y)  =!=  vec4 z)  binopInt ::    (LLVM.Value V4Int32 ~ v) =>@@ -168,7 +152,8 @@ unpackWord3 = unpackWords 8  binopV4I2 ::-   (Eq a, LLVM.IsPrimitive a, LLVM.IsSized a, LLVM.SizeOf a ~ TypeNum.D2,+   (Show a, Eq a,+    LLVM.IsPrimitive a, LLVM.IsSized a, LLVM.SizeOf a ~ TypeNum.D2,     LLVM.Value (V4 a) ~ v) =>    (Word8 -> V4 a) ->    (v -> v -> LLVM.CodeGenFunction () v) ->@@ -182,12 +167,13 @@          vz <- codegen vx vy          LLVM.bitcast vz)       (\(x,y) z ->-         liftA2 fun (unpackBits x) (unpackBits y)  ==  unpackBits z)+         liftA2 fun (unpackBits x) (unpackBits y)  =!=  unpackBits z)  type Code15 r = LLVM.CodeGenFunction r (LLVM.Value (LLVM.WordN TypeNum.D15))  binopV5I3 ::-   (Eq a, LLVM.IsPrimitive a, LLVM.IsSized a, LLVM.SizeOf a ~ TypeNum.D3,+   (Show a, Eq a,+    LLVM.IsPrimitive a, LLVM.IsSized a, LLVM.SizeOf a ~ TypeNum.D3,     LLVM.Value (V5 a) ~ v) =>    (Word16 -> V5 a) ->    (v -> v -> LLVM.CodeGenFunction () v) ->@@ -201,7 +187,7 @@          vz <- codegen vx vy          LLVM.zext =<< (LLVM.bitcast vz :: Code15 r))       (\(x,y) z ->-         liftA2 fun (unpackBits x) (unpackBits y)  ==  unpackBits z)+         liftA2 fun (unpackBits x) (unpackBits y)  =!=  unpackBits z)  binopInt8 ::    (LLVM.Value (V4 Int8) ~ v) =>@@ -298,19 +284,19 @@       (subSatMan $ convertIntN TypeNum.d2) ++     ("sum",-      run Vector.sum (\x y -> Fold.sum (vec4 x) == (y::Int32))) :+      run Vector.sum (\x y -> Fold.sum (vec4 x) =!= (y::Int32))) :    ("cumulate",       run          (uncurry Vector.cumulate)          (\(x0,xv) (y0,yv) ->             scanl (+) x0 (Fold.toList (vec4 xv))-            ==+            =!=             Fold.toList (vec4 yv) ++ [y0::Int32])) :    ("dot",       run          (uncurry Vector.dotProduct)          (\(x,y) z ->-            Fold.sum (liftA2 (*) (vec4 x) (vec4 y))  ==  (z::Int32))) :+            Fold.sum (liftA2 (*) (vec4 x) (vec4 y))  =!=  (z::Int32))) :     ("truncate", unopFloat Vector.truncate (fromInteger . P.truncate)) :    ("floor", unopFloat Vector.floor (fromInteger . P.floor)) :