dph-lifted-copy 0.6.1.1 → 0.7.0.1

raw patch · 7 files changed

+296/−17 lines, 7 filesdep ~basedep ~dph-basedep ~dph-prim-parPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base, dph-base, dph-prim-par, template-haskell, vector

API changes (from Hackage documentation)

Files

• Data/Array/Parallel/Lifted/Closure.hs +123/−2
• Data/Array/Parallel/Lifted/Combinators.hs +53/−1
• Data/Array/Parallel/Lifted/Scalar.hs +58/−0
• Data/Array/Parallel/Lifted/TH/Repr.hs +2/−2
• Data/Array/Parallel/PArray/PDataInstances.hs +46/−2
• Data/Array/Parallel/Prim.hs +8/−4
• dph-lifted-copy.cabal +6/−6

@@ -4,7 +4,8 @@   mkClosure, mkClosureP, ($:), ($:^),   closure, liftedClosure, liftedApply, -  closure1, closure2, closure3, closure4+  closure1, closure2, closure3, closure4, closure5,+  closure6, closure7, closure8 ) where import Data.Array.Parallel.PArray.PReprInstances () import Data.Array.Parallel.PArray.PDataInstances@@ -76,7 +77,7 @@ -- | Apply a closure to its argument. -- ($:) :: forall a b. (a :-> b) -> a -> b-{-# INLINE ($:) #-}+{-# INLINE [1] ($:) #-} Clo f _ e $: a = f e a  {-# RULES@@ -242,3 +243,123 @@      fv_4 (x, y, z) v = fv x y z v     fl_4 ps vs = case unzip3PA# ps of (xs, ys, zs) -> fl xs ys zs vs+++-- | Arity-5 closures.+closure5 :: (PA a, PA b, PA c, PA d, PA e)+         => (a -> b -> c -> d -> e -> f)+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f)+         -> (a :-> b :-> c :-> d :-> e :-> f)++{-# INLINE closure5 #-}+closure5 fv fl = mkClosure fv_1 fl_1 ()+  where+    fv_1 _  x  = mkClosure  fv_2 fl_2 x+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs++    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)++    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)++    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) +    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)++    fv_5 (v, w, x, y) z = fv v w x y z+    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> fl vs ws xs ys zs+++-- | Arity-6 closures.+closure6 :: (PA a, PA b, PA c, PA d, PA e, PA f)+         => (a -> b -> c -> d -> e -> f -> g)+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g)+         -> (a :-> b :-> c :-> d :-> e :-> f :-> g)++{-# INLINE closure6 #-}+closure6 fv fl = mkClosure fv_1 fl_1 ()+  where+    fv_1 _  x  = mkClosure  fv_2 fl_2 x+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs++    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)++    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)++    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) +    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)++    fv_5 (v, w, x, y) z = mkClosure fv_6 fl_6 (v, w, x, y, z) +    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> mkClosureP fv_6 fl_6  (zip5PA# vs ws xs ys zs)++    fv_6 (u, v, w, x, y) z = fv u v w x y z+    fl_6 ps zs = case unzip5PA# ps of (us, vs, ws, xs, ys) -> fl us vs ws xs ys zs++-- | Arity-7 closures.+closure7 :: (PA a, PA b, PA c, PA d, PA e, PA f, PA g)+         => (a -> b -> c -> d -> e -> f -> g -> h)+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e +         -> PArray f -> PArray g -> PArray h)+         -> (a :-> b :-> c :-> d :-> e :-> f :-> g :-> h)++{-# INLINE closure7 #-}+closure7 fv fl = mkClosure fv_1 fl_1 ()+  where+    fv_1 _  x  = mkClosure  fv_2 fl_2 x+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs++    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)++    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)++    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) +    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)++    fv_5 (v, w, x, y) z = mkClosure fv_6 fl_6 (v, w, x, y, z) +    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> mkClosureP fv_6 fl_6  (zip5PA# vs ws xs ys zs)++    fv_6 (u, v, w, x, y) z = mkClosure fv_7 fl_7 (u, v, w, x, y, z) +    fl_6 ps zs = case unzip5PA# ps of (us, vs, ws, xs, ys) -> mkClosureP fv_7 fl_7  (zip6PA# us vs ws xs ys zs)++    fv_7 (t, u, v, w, x, y) z = fv t u v w x y z+    fl_7 ps zs = case unzip6PA# ps of (ts, us, vs, ws, xs, ys) -> fl ts us vs ws xs ys zs++-- | Arity-8 closures.+closure8 :: (PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h)+         => (a -> b -> c -> d -> e -> f -> g -> h -> i)+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e +         -> PArray f -> PArray g -> PArray h -> PArray i)+         -> (a :-> b :-> c :-> d :-> e :-> f :-> g :-> h :-> i)++{-# INLINE closure8 #-}+closure8 fv fl = mkClosure fv_1 fl_1 ()+  where+    fv_1 _  x  = mkClosure  fv_2 fl_2 x+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs++    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)++    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)++    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) +    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)++    fv_5 (v, w, x, y) z = mkClosure fv_6 fl_6 (v, w, x, y, z) +    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> mkClosureP fv_6 fl_6  (zip5PA# vs ws xs ys zs)++    fv_6 (u, v, w, x, y) z = mkClosure fv_7 fl_7 (u, v, w, x, y, z) +    fl_6 ps zs = case unzip5PA# ps of (us, vs, ws, xs, ys) -> mkClosureP fv_7 fl_7  (zip6PA# us vs ws xs ys zs)++    fv_7 (t, u, v, w, x, y) z = mkClosure fv_8 fl_8 (t, u, v, w, x, y, z) +    fl_7 ps zs = case unzip6PA# ps of (ts, us, vs, ws, xs, ys) -> mkClosureP fv_8 fl_8  (zip7PA# ts us vs ws xs ys zs)++    fv_8 (s, t, u, v, w, x, y) z = fv s t u v w x y z+    fl_8 ps zs = case unzip7PA# ps of (ss, ts, us, vs, ws, xs, ys) -> fl ss ts us vs ws xs ys zs++   

@@ -23,7 +23,8 @@ -- module Data.Array.Parallel.Lifted.Combinators (   lengthPA, replicatePA, singletonPA, mapPA, crossMapPA,-  zipPA, zip3PA, zipWithPA, zipWith3PA, unzipPA, unzip3PA, +  zipPA, zip3PA, zip4PA, zipWithPA, zipWith3PA, unzipPA, unzip3PA, unzip4PA ,+  zipWith4PA,   packPA, filterPA, combine2PA, indexPA, concatPA, appPA, enumFromToPA_Int,   indexedPA, slicePA, updatePA, bpermutePA, @@ -191,6 +192,22 @@   = PArray n# (PNested segd (P_3 xs ys zs))  ++zip4PA :: (PA a, PA b, PA c, PA d) => PArray a :-> PArray b :-> PArray c :-> PArray d :-> PArray (a, b, c, d)+{-# INLINE zip4PA #-}+zip4PA = closure4 zip4PA_v zip4PA_l++zip4PA_v :: (PA a, PA b, PA c, PA d) => PArray a -> PArray b -> PArray c -> PArray d -> PArray (a, b, c, d)+{-# INLINE_PA zip4PA_v #-}+zip4PA_v xs ys = zip4PA# xs ys++zip4PA_l :: (PA a, PA b, PA c, PA d)+         => PArray (PArray a) -> PArray (PArray b) -> PArray (PArray c) -> PArray (PArray d) -> PArray (PArray (a, b, c, d))+{-# INLINE_PA zip4PA_l #-}+zip4PA_l (PArray n# (PNested segd ws)) (PArray _ (PNested _ xs)) (PArray _ (PNested _ ys)) (PArray _ (PNested _ zs))+  = PArray n# (PNested segd (P_4 ws xs ys zs))++ -- zipWith -------------------------------------------------------------------- -- |Map a function over multiple arrays at once. @@ -233,6 +250,26 @@       (replicatelPA# (segdPA# ass) fs $:^ concatPA# ass $:^ concatPA# bss $:^ concatPA# css)  +zipWith4PA :: (PA a, PA b, PA c, PA d, PA e)+           => (a :-> b :-> c :-> d :-> e) :-> PArray a :-> PArray b :-> PArray c :-> PArray d :-> PArray e+{-# INLINE zipWith4PA #-}+zipWith4PA = closure5 zipWith4PA_v zipWith4PA_l++zipWith4PA_v :: (PA a, PA b, PA c, PA d, PA e)+             => (a :-> b :-> c :-> d :-> e) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e+{-# INLINE_PA zipWith4PA_v #-}+zipWith4PA_v f as bs cs ds = replicatePA# (lengthPA# as) f $:^ as $:^ bs $:^ cs $:^ ds++zipWith4PA_l :: (PA a, PA b, PA c, PA d, PA e)+             => PArray (a :-> b :-> c :-> d :-> e) +             -> PArray (PArray a) -> PArray (PArray b) -> PArray (PArray c)+             -> PArray (PArray d) -> PArray (PArray e)+{-# INLINE_PA zipWith4PA_l #-}+zipWith4PA_l fs ass bss css dss+  = copySegdPA# ass+      (replicatelPA# (segdPA# ass) fs $:^ concatPA# ass $:^ concatPA# bss $:^ concatPA# css $:^ concatPA# dss)++ -- unzip ---------------------------------------------------------------------- -- |Transform an array of tuples into a tuple of arrays. @@ -263,6 +300,21 @@ unzip3PA_l xyzss = zip3PA# (copySegdPA# xyzss xs) (copySegdPA# xyzss ys) (copySegdPA# xyzss zs)   where     (xs, ys, zs) = unzip3PA# (concatPA# xyzss)+++unzip4PA :: (PA a, PA b, PA c, PA d) => PArray (a, b, c, d) :-> (PArray a, PArray b, PArray c, PArray d)+{-# INLINE unzip4PA #-}+unzip4PA = closure1 unzip4PA_v unzip4PA_l++unzip4PA_v :: (PA a, PA b, PA c, PA d) => PArray (a, b, c, d) -> (PArray a, PArray b, PArray c, PArray d)+{-# INLINE_PA unzip4PA_v #-}+unzip4PA_v abs' = unzip4PA# abs'++unzip4PA_l :: (PA a, PA b, PA c) => PArray (PArray (a, b, c, d)) -> PArray (PArray a, PArray b, PArray c, PArray d)+{-# INLINE_PA unzip4PA_l #-}+unzip4PA_l wxyzss = zip4PA# (copySegdPA# wxyzss ws) (copySegdPA# wxyzss xs) (copySegdPA# wxyzss ys) (copySegdPA# wxyzss zs) +  where+    (ws, xs, ys, zs) = unzip4PA# (concatPA# wxyzss)    -- packPA ---------------------------------------------------------------------

@@ -132,6 +132,64 @@         $ U.zipWith3 f (toUArray xs) (toUArray ys) (toUArray zs)  +++-- | Zip four arrays, yielding a new array.+scalar_zipWith4+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e)+        => (a -> b -> c -> d -> e) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e++{-# INLINE_PA scalar_zipWith4 #-}+scalar_zipWith4 f ws xs ys zs +        = fromUArray' (prim_lengthPA ws)+        $ U.zipWith4 f (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)+++-- | Zip five arrays, yielding a new array.+scalar_zipWith5+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f)+        => (a -> b -> c -> d -> e -> f) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f++{-# INLINE_PA scalar_zipWith5 #-}+scalar_zipWith5 f vs ws xs ys zs  +        = fromUArray' (prim_lengthPA vs)+        $ U.zipWith5 f (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)+        +        +-- | Zip six arrays, yielding a new array.+scalar_zipWith6+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g)+        => (a -> b -> c -> d -> e -> f -> g) +        -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray  f-> PArray g++{-# INLINE_PA scalar_zipWith6 #-}+scalar_zipWith6 f us vs ws xs ys zs +        = fromUArray' (prim_lengthPA us)+        $ U.zipWith6 f (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)+        +-- | Zip seven arrays, yielding a new array.+scalar_zipWith7+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g, Scalar h)+        => (a -> b -> c -> d -> e -> f -> g -> h) +        -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray  f-> PArray g -> PArray h++{-# INLINE_PA scalar_zipWith7 #-}+scalar_zipWith7 f ts us vs ws xs ys zs +        = fromUArray' (prim_lengthPA us)+        $ U.zipWith7 f (toUArray ts) (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)+                        ++-- | Zip eight arrays, yielding a new array.+scalar_zipWith8+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g, Scalar h, Scalar i)+        => (a -> b -> c -> d -> e -> f -> g -> h -> i) +        -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray  f-> PArray g -> PArray h -> PArray i++{-# INLINE_PA scalar_zipWith8 #-}+scalar_zipWith8 f ss ts us vs ws xs ys zs +        = fromUArray' (prim_lengthPA ss)+        $ U.zipWith8 f (toUArray ss)  (toUArray ts) (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)+                         -- | Left fold over an array. scalar_fold          :: Scalar a

@@ -1,4 +1,4 @@-{-# LANGUAGE TemplateHaskell, Rank2Types #-}+{-# LANGUAGE TemplateHaskell, RankNTypes #-} module Data.Array.Parallel.Lifted.TH.Repr (   scalarInstances, tupleInstances,   voidPRInstance, unitPRInstance, wrapPRInstance@@ -46,7 +46,7 @@   inlineD :: Name -> DecQ-inlineD name = pragInlD name (inlineSpecNoPhase True False)+inlineD name = pragInlD name Inline FunLike AllPhases   instance_PData :: TypeQ -> [Name] -> Name -> [TypeQ] -> DecQ

@@ -10,8 +10,9 @@   punit,    -- * Operators on arrays of tuples-  zipPA#,  unzipPA#, zip3PA#, unzip3PA#,-  zip4PA#, zip5PA#, +  zipPA#,  unzipPA#, zip3PA#, unzip3PA#, +  zip4PA#, unzip4PA#, zip5PA#, unzip5PA#, zip6PA#, unzip6PA#, +  zip7PA#, unzip7PA#, zip8PA#, unzip8PA#,       -- * Operators on nested arrays   segdPA#, concatPA#, segmentPA#, copySegdPA#@@ -281,10 +282,53 @@ zip4PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as)   = PArray n# (P_4 xs ys zs as) +unzip4PA# :: PArray (a, b, c, d) -> (PArray a, PArray b, PArray c, PArray d)+{-# INLINE_PA unzip4PA# #-}+unzip4PA# (PArray n# (P_4 ws xs ys zs))+   = (PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)+ zip5PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray (a, b, c, d, e) {-# INLINE_PA zip5PA# #-} zip5PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs)   = PArray n# (P_5 xs ys zs as bs)++unzip5PA# :: PArray (a, b, c, d, e) -> (PArray a, PArray b, PArray c, PArray d, PArray e)+{-# INLINE_PA unzip5PA# #-}+unzip5PA# (PArray n# (P_5 vs ws xs ys zs))+  = (PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)++zip6PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray (a, b, c, d, e, f)+{-# INLINE_PA zip6PA# #-}+zip6PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs) (PArray _ cs)+  = PArray n# (P_6 xs ys zs as bs cs)++unzip6PA# :: PArray (a, b, c, d, e, f) -> (PArray a, PArray b, PArray c, PArray d, PArray e, PArray f)+{-# INLINE_PA unzip6PA# #-}+unzip6PA# (PArray n# (P_6 us vs ws xs ys zs))+  = (PArray n# us, PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)+++zip7PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g ->+  PArray (a, b, c, d, e, f, g)+{-# INLINE_PA zip7PA# #-}+zip7PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs) (PArray _ cs) (PArray _ ds)+  = PArray n# (P_7 xs ys zs as bs cs ds)++unzip7PA# :: PArray (a, b, c, d, e, f, g) -> (PArray a, PArray b, PArray c, PArray d, PArray e, PArray f, PArray g)+{-# INLINE_PA unzip7PA# #-}+unzip7PA# (PArray n# (P_7 ts us vs ws xs ys zs))+  = (PArray n# ts, PArray n# us, PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)++zip8PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g -> PArray h ->+  PArray (a, b, c, d, e, f, g, h)+{-# INLINE_PA zip8PA# #-}+zip8PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs) (PArray _ cs) (PArray _ ds) (PArray _ es)+  = PArray n# (P_8 xs ys zs as bs cs ds es)++unzip8PA# :: PArray (a, b, c, d, e, f, g, h) -> (PArray a, PArray b, PArray c, PArray d, PArray e, PArray f, PArray g, PArray h)+{-# INLINE_PA unzip8PA# #-}+unzip8PA# (PArray n# (P_8 ss ts us vs ws xs ys zs))+  = (PArray n# ss, PArray n# ts, PArray n# us, PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)   -- Sums -----------------------------------------------------------------------

@@ -17,11 +17,13 @@   PData, PDatas(..), PRepr, PA(..), PR(..),   replicatePD, emptyPD, packByTagPD, combine2PD,   Scalar(..),-  scalar_map, scalar_zipWith, scalar_zipWith3,+  scalar_map, scalar_zipWith, scalar_zipWith3, scalar_zipWith4, scalar_zipWith5, scalar_zipWith6,+  scalar_zipWith7, scalar_zipWith8,   Void, Sum2(..), Sum3(..), Wrap(..),   void, fromVoid, pvoid, pvoids#, punit,   (:->)(..), -  closure, liftedClosure, ($:), liftedApply, closure1, closure2, closure3,+  closure, liftedClosure, ($:), liftedApply, closure1, closure2, closure3, closure4, +  closure5, closure6, closure7, closure8,   Sel2,  replicateSel2#, tagsSel2, elementsSel2_0#, elementsSel2_1#,   Sels2, lengthSels2#,   replicatePA_Int#, replicatePA_Double#,@@ -45,14 +47,16 @@ import Data.Array.Parallel.PArray.PData           (PData, PDatas, PR(..)) import Data.Array.Parallel.PArray.PDataInstances  (pvoid, punit, Sels2) import Data.Array.Parallel.Lifted.Closure         ((:->)(..), closure, liftedClosure, ($:),-                                                   liftedApply, closure1, closure2, closure3)+                                                   liftedApply, closure1, closure2, closure3, closure4, +												   closure5, closure6, closure7, closure8) import Data.Array.Parallel.Lifted.Unboxed         (Sel2, replicateSel2#, tagsSel2, elementsSel2_0#,                                                    elementsSel2_1#,                                                    replicatePA_Int#, replicatePA_Double#,                                                    emptyPA_Int#, emptyPA_Double#,                                                    {- packByTagPA_Int#, packByTagPA_Double# -}                                                    combine2PA_Int#, combine2PA_Double#)-import Data.Array.Parallel.Lifted.Scalar          (scalar_map, scalar_zipWith, scalar_zipWith3)+import Data.Array.Parallel.Lifted.Scalar          (scalar_map, scalar_zipWith, scalar_zipWith3, scalar_zipWith4,+                                                   scalar_zipWith5, scalar_zipWith6, scalar_zipWith7, scalar_zipWith8) import Data.Array.Parallel.Prelude.Tuple          (tup2, tup3, tup4) import GHC.Exts 

@@ -1,5 +1,5 @@ Name:           dph-lifted-copy-Version:        0.6.1.1+Version:        0.7.0.1 License:        BSD3 License-File:   LICENSE Author:         The DPH Team@@ -64,11 +64,11 @@         -fno-warn-missing-signatures    Build-Depends:  -        base             == 4.5.*,+        base             == 4.6.*,         ghc              == 7.*,         array            == 0.4.*,         random           == 1.0.*,-        template-haskell == 2.7.*,-        vector           == 0.9.*,-        dph-base         == 0.6.1.*,-        dph-prim-par     == 0.6.1.*+        template-haskell == 2.8.*,+        dph-base         == 0.7.*,+        dph-prim-par     == 0.7.*,+        vector           == 0.10.*