Rename unsafeFreeze to basicUnsafeFreeze and add unsafeFreeze as a free function
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
1 #ifdef DEFINE_INSTANCES
2 data instance MVector s (a, b)
3     = MV_2 {-# UNPACK #-} !Int !(MVector s a)
4                                !(MVector s b)
5 data instance Vector (a, b)
6     = V_2 {-# UNPACK #-} !Int !(Vector a)
7                               !(Vector b)
8 instance (Unbox a, Unbox b) => Unbox (a, b)
9 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
10   {-# INLINE basicLength  #-}
11   basicLength (MV_2 n_ as bs) = n_
12   {-# INLINE basicUnsafeSlice  #-}
13   basicUnsafeSlice i_ m_ (MV_2 n_ as bs)
14       = MV_2 m_ (M.basicUnsafeSlice i_ m_ as)
15                 (M.basicUnsafeSlice i_ m_ bs)
16   {-# INLINE basicOverlaps  #-}
17   basicOverlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
18       = M.basicOverlaps as1 as2
19         || M.basicOverlaps bs1 bs2
20   {-# INLINE basicUnsafeNew  #-}
21   basicUnsafeNew n_
22       = do
23           as <- M.basicUnsafeNew n_
24           bs <- M.basicUnsafeNew n_
25           return $ MV_2 n_ as bs
26   {-# INLINE basicUnsafeReplicate  #-}
27   basicUnsafeReplicate n_ (a, b)
28       = do
29           as <- M.basicUnsafeReplicate n_ a
30           bs <- M.basicUnsafeReplicate n_ b
31           return $ MV_2 n_ as bs
32   {-# INLINE basicUnsafeRead  #-}
33   basicUnsafeRead (MV_2 n_ as bs) i_
34       = do
35           a <- M.basicUnsafeRead as i_
36           b <- M.basicUnsafeRead bs i_
37           return (a, b)
38   {-# INLINE basicUnsafeWrite  #-}
39   basicUnsafeWrite (MV_2 n_ as bs) i_ (a, b)
40       = do
41           M.basicUnsafeWrite as i_ a
42           M.basicUnsafeWrite bs i_ b
43   {-# INLINE basicClear  #-}
44   basicClear (MV_2 n_ as bs)
45       = do
46           M.basicClear as
47           M.basicClear bs
48   {-# INLINE basicSet  #-}
49   basicSet (MV_2 n_ as bs) (a, b)
50       = do
51           M.basicSet as a
52           M.basicSet bs b
53   {-# INLINE basicUnsafeCopy  #-}
54   basicUnsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
55       = do
56           M.basicUnsafeCopy as1 as2
57           M.basicUnsafeCopy bs1 bs2
58   {-# INLINE basicUnsafeGrow  #-}
59   basicUnsafeGrow (MV_2 n_ as bs) m_
60       = do
61           as' <- M.basicUnsafeGrow as m_
62           bs' <- M.basicUnsafeGrow bs m_
63           return $ MV_2 (m_+n_) as' bs'
64 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
65   {-# INLINE basicUnsafeFreeze  #-}
66   basicUnsafeFreeze (MV_2 n_ as bs)
67       = do
68           as' <- G.basicUnsafeFreeze as
69           bs' <- G.basicUnsafeFreeze bs
70           return $ V_2 n_ as' bs'
71   {-# INLINE basicLength  #-}
72   basicLength (V_2 n_ as bs) = n_
73   {-# INLINE basicUnsafeSlice  #-}
74   basicUnsafeSlice i_ m_ (V_2 n_ as bs)
75       = V_2 m_ (G.basicUnsafeSlice i_ m_ as)
76                (G.basicUnsafeSlice i_ m_ bs)
77   {-# INLINE basicUnsafeIndexM  #-}
78   basicUnsafeIndexM (V_2 n_ as bs) i_
79       = do
80           a <- G.basicUnsafeIndexM as i_
81           b <- G.basicUnsafeIndexM bs i_
82           return (a, b)
83   {-# INLINE basicUnsafeCopy  #-}
84   basicUnsafeCopy (MV_2 n_1 as1 bs1) (V_2 n_2 as2 bs2)
85       = do
86           G.basicUnsafeCopy as1 as2
87           G.basicUnsafeCopy bs1 bs2
88   {-# INLINE elemseq  #-}
89   elemseq _ (a, b)
90       = G.elemseq (undefined :: Vector a) a
91         . G.elemseq (undefined :: Vector b) b
92 #endif
93 #ifdef DEFINE_MUTABLE
94 -- | /O(1)/ Zip 2 vectors
95 zip :: (Unbox a, Unbox b) => MVector s a ->
96                              MVector s b -> MVector s (a, b)
97 {-# INLINE_STREAM zip #-}
98 zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
99   where len = length as `min` length bs
100 -- | /O(1)/ Unzip 2 vectors
101 unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
102                                                     MVector s b)
103 {-# INLINE unzip #-}
104 unzip (MV_2 n_ as bs) = (as, bs)
105 #endif
106 #ifdef DEFINE_IMMUTABLE
107 -- | /O(1)/ Zip 2 vectors
108 zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
109 {-# INLINE_STREAM zip #-}
110 zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
111   where len = length as `min` length bs
112 {-# RULES "stream/zip [Vector.Unboxed]" forall as bs .
113   G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
114                                             (G.stream bs)
115   #-}
116 -- | /O(1)/ Unzip 2 vectors
117 unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a,
118                                                  Vector b)
119 {-# INLINE unzip #-}
120 unzip (V_2 n_ as bs) = (as, bs)
121 #endif
122 #ifdef DEFINE_INSTANCES
123 data instance MVector s (a, b, c)
124     = MV_3 {-# UNPACK #-} !Int !(MVector s a)
125                                !(MVector s b)
126                                !(MVector s c)
127 data instance Vector (a, b, c)
128     = V_3 {-# UNPACK #-} !Int !(Vector a)
129                               !(Vector b)
130                               !(Vector c)
131 instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
132 instance (Unbox a,
133           Unbox b,
134           Unbox c) => M.MVector MVector (a, b, c) where
135   {-# INLINE basicLength  #-}
136   basicLength (MV_3 n_ as bs cs) = n_
137   {-# INLINE basicUnsafeSlice  #-}
138   basicUnsafeSlice i_ m_ (MV_3 n_ as bs cs)
139       = MV_3 m_ (M.basicUnsafeSlice i_ m_ as)
140                 (M.basicUnsafeSlice i_ m_ bs)
141                 (M.basicUnsafeSlice i_ m_ cs)
142   {-# INLINE basicOverlaps  #-}
143   basicOverlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
144       = M.basicOverlaps as1 as2
145         || M.basicOverlaps bs1 bs2
146         || M.basicOverlaps cs1 cs2
147   {-# INLINE basicUnsafeNew  #-}
148   basicUnsafeNew n_
149       = do
150           as <- M.basicUnsafeNew n_
151           bs <- M.basicUnsafeNew n_
152           cs <- M.basicUnsafeNew n_
153           return $ MV_3 n_ as bs cs
154   {-# INLINE basicUnsafeReplicate  #-}
155   basicUnsafeReplicate n_ (a, b, c)
156       = do
157           as <- M.basicUnsafeReplicate n_ a
158           bs <- M.basicUnsafeReplicate n_ b
159           cs <- M.basicUnsafeReplicate n_ c
160           return $ MV_3 n_ as bs cs
161   {-# INLINE basicUnsafeRead  #-}
162   basicUnsafeRead (MV_3 n_ as bs cs) i_
163       = do
164           a <- M.basicUnsafeRead as i_
165           b <- M.basicUnsafeRead bs i_
166           c <- M.basicUnsafeRead cs i_
167           return (a, b, c)
168   {-# INLINE basicUnsafeWrite  #-}
169   basicUnsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
170       = do
171           M.basicUnsafeWrite as i_ a
172           M.basicUnsafeWrite bs i_ b
173           M.basicUnsafeWrite cs i_ c
174   {-# INLINE basicClear  #-}
175   basicClear (MV_3 n_ as bs cs)
176       = do
177           M.basicClear as
178           M.basicClear bs
179           M.basicClear cs
180   {-# INLINE basicSet  #-}
181   basicSet (MV_3 n_ as bs cs) (a, b, c)
182       = do
183           M.basicSet as a
184           M.basicSet bs b
185           M.basicSet cs c
186   {-# INLINE basicUnsafeCopy  #-}
187   basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
188       = do
189           M.basicUnsafeCopy as1 as2
190           M.basicUnsafeCopy bs1 bs2
191           M.basicUnsafeCopy cs1 cs2
192   {-# INLINE basicUnsafeGrow  #-}
193   basicUnsafeGrow (MV_3 n_ as bs cs) m_
194       = do
195           as' <- M.basicUnsafeGrow as m_
196           bs' <- M.basicUnsafeGrow bs m_
197           cs' <- M.basicUnsafeGrow cs m_
198           return $ MV_3 (m_+n_) as' bs' cs'
199 instance (Unbox a,
200           Unbox b,
201           Unbox c) => G.Vector Vector (a, b, c) where
202   {-# INLINE basicUnsafeFreeze  #-}
203   basicUnsafeFreeze (MV_3 n_ as bs cs)
204       = do
205           as' <- G.basicUnsafeFreeze as
206           bs' <- G.basicUnsafeFreeze bs
207           cs' <- G.basicUnsafeFreeze cs
208           return $ V_3 n_ as' bs' cs'
209   {-# INLINE basicLength  #-}
210   basicLength (V_3 n_ as bs cs) = n_
211   {-# INLINE basicUnsafeSlice  #-}
212   basicUnsafeSlice i_ m_ (V_3 n_ as bs cs)
213       = V_3 m_ (G.basicUnsafeSlice i_ m_ as)
214                (G.basicUnsafeSlice i_ m_ bs)
215                (G.basicUnsafeSlice i_ m_ cs)
216   {-# INLINE basicUnsafeIndexM  #-}
217   basicUnsafeIndexM (V_3 n_ as bs cs) i_
218       = do
219           a <- G.basicUnsafeIndexM as i_
220           b <- G.basicUnsafeIndexM bs i_
221           c <- G.basicUnsafeIndexM cs i_
222           return (a, b, c)
223   {-# INLINE basicUnsafeCopy  #-}
224   basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (V_3 n_2 as2 bs2 cs2)
225       = do
226           G.basicUnsafeCopy as1 as2
227           G.basicUnsafeCopy bs1 bs2
228           G.basicUnsafeCopy cs1 cs2
229   {-# INLINE elemseq  #-}
230   elemseq _ (a, b, c)
231       = G.elemseq (undefined :: Vector a) a
232         . G.elemseq (undefined :: Vector b) b
233         . G.elemseq (undefined :: Vector c) c
234 #endif
235 #ifdef DEFINE_MUTABLE
236 -- | /O(1)/ Zip 3 vectors
237 zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
238                                        MVector s b ->
239                                        MVector s c -> MVector s (a, b, c)
240 {-# INLINE_STREAM zip3 #-}
241 zip3 as bs cs = MV_3 len (unsafeSlice 0 len as)
242                          (unsafeSlice 0 len bs)
243                          (unsafeSlice 0 len cs)
244   where len = length as `min` length bs `min` length cs
245 -- | /O(1)/ Unzip 3 vectors
246 unzip3 :: (Unbox a,
247            Unbox b,
248            Unbox c) => MVector s (a, b, c) -> (MVector s a,
249                                                MVector s b,
250                                                MVector s c)
251 {-# INLINE unzip3 #-}
252 unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
253 #endif
254 #ifdef DEFINE_IMMUTABLE
255 -- | /O(1)/ Zip 3 vectors
256 zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
257                                        Vector b ->
258                                        Vector c -> Vector (a, b, c)
259 {-# INLINE_STREAM zip3 #-}
260 zip3 as bs cs = V_3 len (unsafeSlice 0 len as)
261                         (unsafeSlice 0 len bs)
262                         (unsafeSlice 0 len cs)
263   where len = length as `min` length bs `min` length cs
264 {-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs .
265   G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as)
266                                                    (G.stream bs)
267                                                    (G.stream cs)
268   #-}
269 -- | /O(1)/ Unzip 3 vectors
270 unzip3 :: (Unbox a,
271            Unbox b,
272            Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
273 {-# INLINE unzip3 #-}
274 unzip3 (V_3 n_ as bs cs) = (as, bs, cs)
275 #endif
276 #ifdef DEFINE_INSTANCES
277 data instance MVector s (a, b, c, d)
278     = MV_4 {-# UNPACK #-} !Int !(MVector s a)
279                                !(MVector s b)
280                                !(MVector s c)
281                                !(MVector s d)
282 data instance Vector (a, b, c, d)
283     = V_4 {-# UNPACK #-} !Int !(Vector a)
284                               !(Vector b)
285                               !(Vector c)
286                               !(Vector d)
287 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
288 instance (Unbox a,
289           Unbox b,
290           Unbox c,
291           Unbox d) => M.MVector MVector (a, b, c, d) where
292   {-# INLINE basicLength  #-}
293   basicLength (MV_4 n_ as bs cs ds) = n_
294   {-# INLINE basicUnsafeSlice  #-}
295   basicUnsafeSlice i_ m_ (MV_4 n_ as bs cs ds)
296       = MV_4 m_ (M.basicUnsafeSlice i_ m_ as)
297                 (M.basicUnsafeSlice i_ m_ bs)
298                 (M.basicUnsafeSlice i_ m_ cs)
299                 (M.basicUnsafeSlice i_ m_ ds)
300   {-# INLINE basicOverlaps  #-}
301   basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
302       = M.basicOverlaps as1 as2
303         || M.basicOverlaps bs1 bs2
304         || M.basicOverlaps cs1 cs2
305         || M.basicOverlaps ds1 ds2
306   {-# INLINE basicUnsafeNew  #-}
307   basicUnsafeNew n_
308       = do
309           as <- M.basicUnsafeNew n_
310           bs <- M.basicUnsafeNew n_
311           cs <- M.basicUnsafeNew n_
312           ds <- M.basicUnsafeNew n_
313           return $ MV_4 n_ as bs cs ds
314   {-# INLINE basicUnsafeReplicate  #-}
315   basicUnsafeReplicate n_ (a, b, c, d)
316       = do
317           as <- M.basicUnsafeReplicate n_ a
318           bs <- M.basicUnsafeReplicate n_ b
319           cs <- M.basicUnsafeReplicate n_ c
320           ds <- M.basicUnsafeReplicate n_ d
321           return $ MV_4 n_ as bs cs ds
322   {-# INLINE basicUnsafeRead  #-}
323   basicUnsafeRead (MV_4 n_ as bs cs ds) i_
324       = do
325           a <- M.basicUnsafeRead as i_
326           b <- M.basicUnsafeRead bs i_
327           c <- M.basicUnsafeRead cs i_
328           d <- M.basicUnsafeRead ds i_
329           return (a, b, c, d)
330   {-# INLINE basicUnsafeWrite  #-}
331   basicUnsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
332       = do
333           M.basicUnsafeWrite as i_ a
334           M.basicUnsafeWrite bs i_ b
335           M.basicUnsafeWrite cs i_ c
336           M.basicUnsafeWrite ds i_ d
337   {-# INLINE basicClear  #-}
338   basicClear (MV_4 n_ as bs cs ds)
339       = do
340           M.basicClear as
341           M.basicClear bs
342           M.basicClear cs
343           M.basicClear ds
344   {-# INLINE basicSet  #-}
345   basicSet (MV_4 n_ as bs cs ds) (a, b, c, d)
346       = do
347           M.basicSet as a
348           M.basicSet bs b
349           M.basicSet cs c
350           M.basicSet ds d
351   {-# INLINE basicUnsafeCopy  #-}
352   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
353                                                        bs2
354                                                        cs2
355                                                        ds2)
356       = do
357           M.basicUnsafeCopy as1 as2
358           M.basicUnsafeCopy bs1 bs2
359           M.basicUnsafeCopy cs1 cs2
360           M.basicUnsafeCopy ds1 ds2
361   {-# INLINE basicUnsafeGrow  #-}
362   basicUnsafeGrow (MV_4 n_ as bs cs ds) m_
363       = do
364           as' <- M.basicUnsafeGrow as m_
365           bs' <- M.basicUnsafeGrow bs m_
366           cs' <- M.basicUnsafeGrow cs m_
367           ds' <- M.basicUnsafeGrow ds m_
368           return $ MV_4 (m_+n_) as' bs' cs' ds'
369 instance (Unbox a,
370           Unbox b,
371           Unbox c,
372           Unbox d) => G.Vector Vector (a, b, c, d) where
373   {-# INLINE basicUnsafeFreeze  #-}
374   basicUnsafeFreeze (MV_4 n_ as bs cs ds)
375       = do
376           as' <- G.basicUnsafeFreeze as
377           bs' <- G.basicUnsafeFreeze bs
378           cs' <- G.basicUnsafeFreeze cs
379           ds' <- G.basicUnsafeFreeze ds
380           return $ V_4 n_ as' bs' cs' ds'
381   {-# INLINE basicLength  #-}
382   basicLength (V_4 n_ as bs cs ds) = n_
383   {-# INLINE basicUnsafeSlice  #-}
384   basicUnsafeSlice i_ m_ (V_4 n_ as bs cs ds)
385       = V_4 m_ (G.basicUnsafeSlice i_ m_ as)
386                (G.basicUnsafeSlice i_ m_ bs)
387                (G.basicUnsafeSlice i_ m_ cs)
388                (G.basicUnsafeSlice i_ m_ ds)
389   {-# INLINE basicUnsafeIndexM  #-}
390   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
391       = do
392           a <- G.basicUnsafeIndexM as i_
393           b <- G.basicUnsafeIndexM bs i_
394           c <- G.basicUnsafeIndexM cs i_
395           d <- G.basicUnsafeIndexM ds i_
396           return (a, b, c, d)
397   {-# INLINE basicUnsafeCopy  #-}
398   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (V_4 n_2 as2
399                                                       bs2
400                                                       cs2
401                                                       ds2)
402       = do
403           G.basicUnsafeCopy as1 as2
404           G.basicUnsafeCopy bs1 bs2
405           G.basicUnsafeCopy cs1 cs2
406           G.basicUnsafeCopy ds1 ds2
407   {-# INLINE elemseq  #-}
408   elemseq _ (a, b, c, d)
409       = G.elemseq (undefined :: Vector a) a
410         . G.elemseq (undefined :: Vector b) b
411         . G.elemseq (undefined :: Vector c) c
412         . G.elemseq (undefined :: Vector d) d
413 #endif
414 #ifdef DEFINE_MUTABLE
415 -- | /O(1)/ Zip 4 vectors
416 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
417                                                 MVector s b ->
418                                                 MVector s c ->
419                                                 MVector s d -> MVector s (a, b, c, d)
420 {-# INLINE_STREAM zip4 #-}
421 zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as)
422                             (unsafeSlice 0 len bs)
423                             (unsafeSlice 0 len cs)
424                             (unsafeSlice 0 len ds)
425   where
426     len = length as `min` length bs `min` length cs `min` length ds
427 -- | /O(1)/ Unzip 4 vectors
428 unzip4 :: (Unbox a,
429            Unbox b,
430            Unbox c,
431            Unbox d) => MVector s (a, b, c, d) -> (MVector s a,
432                                                   MVector s b,
433                                                   MVector s c,
434                                                   MVector s d)
435 {-# INLINE unzip4 #-}
436 unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
437 #endif
438 #ifdef DEFINE_IMMUTABLE
439 -- | /O(1)/ Zip 4 vectors
440 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
441                                                 Vector b ->
442                                                 Vector c ->
443                                                 Vector d -> Vector (a, b, c, d)
444 {-# INLINE_STREAM zip4 #-}
445 zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as)
446                            (unsafeSlice 0 len bs)
447                            (unsafeSlice 0 len cs)
448                            (unsafeSlice 0 len ds)
449   where
450     len = length as `min` length bs `min` length cs `min` length ds
451 {-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds .
452   G.stream (zip4 as bs cs ds) = Stream.zipWith4 (, , ,) (G.stream as)
453                                                         (G.stream bs)
454                                                         (G.stream cs)
455                                                         (G.stream ds)
456   #-}
457 -- | /O(1)/ Unzip 4 vectors
458 unzip4 :: (Unbox a,
459            Unbox b,
460            Unbox c,
461            Unbox d) => Vector (a, b, c, d) -> (Vector a,
462                                                Vector b,
463                                                Vector c,
464                                                Vector d)
465 {-# INLINE unzip4 #-}
466 unzip4 (V_4 n_ as bs cs ds) = (as, bs, cs, ds)
467 #endif
468 #ifdef DEFINE_INSTANCES
469 data instance MVector s (a, b, c, d, e)
470     = MV_5 {-# UNPACK #-} !Int !(MVector s a)
471                                !(MVector s b)
472                                !(MVector s c)
473                                !(MVector s d)
474                                !(MVector s e)
475 data instance Vector (a, b, c, d, e)
476     = V_5 {-# UNPACK #-} !Int !(Vector a)
477                               !(Vector b)
478                               !(Vector c)
479                               !(Vector d)
480                               !(Vector e)
481 instance (Unbox a,
482           Unbox b,
483           Unbox c,
484           Unbox d,
485           Unbox e) => Unbox (a, b, c, d, e)
486 instance (Unbox a,
487           Unbox b,
488           Unbox c,
489           Unbox d,
490           Unbox e) => M.MVector MVector (a, b, c, d, e) where
491   {-# INLINE basicLength  #-}
492   basicLength (MV_5 n_ as bs cs ds es) = n_
493   {-# INLINE basicUnsafeSlice  #-}
494   basicUnsafeSlice i_ m_ (MV_5 n_ as bs cs ds es)
495       = MV_5 m_ (M.basicUnsafeSlice i_ m_ as)
496                 (M.basicUnsafeSlice i_ m_ bs)
497                 (M.basicUnsafeSlice i_ m_ cs)
498                 (M.basicUnsafeSlice i_ m_ ds)
499                 (M.basicUnsafeSlice i_ m_ es)
500   {-# INLINE basicOverlaps  #-}
501   basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
502                                                          bs2
503                                                          cs2
504                                                          ds2
505                                                          es2)
506       = M.basicOverlaps as1 as2
507         || M.basicOverlaps bs1 bs2
508         || M.basicOverlaps cs1 cs2
509         || M.basicOverlaps ds1 ds2
510         || M.basicOverlaps es1 es2
511   {-# INLINE basicUnsafeNew  #-}
512   basicUnsafeNew n_
513       = do
514           as <- M.basicUnsafeNew n_
515           bs <- M.basicUnsafeNew n_
516           cs <- M.basicUnsafeNew n_
517           ds <- M.basicUnsafeNew n_
518           es <- M.basicUnsafeNew n_
519           return $ MV_5 n_ as bs cs ds es
520   {-# INLINE basicUnsafeReplicate  #-}
521   basicUnsafeReplicate n_ (a, b, c, d, e)
522       = do
523           as <- M.basicUnsafeReplicate n_ a
524           bs <- M.basicUnsafeReplicate n_ b
525           cs <- M.basicUnsafeReplicate n_ c
526           ds <- M.basicUnsafeReplicate n_ d
527           es <- M.basicUnsafeReplicate n_ e
528           return $ MV_5 n_ as bs cs ds es
529   {-# INLINE basicUnsafeRead  #-}
530   basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
531       = do
532           a <- M.basicUnsafeRead as i_
533           b <- M.basicUnsafeRead bs i_
534           c <- M.basicUnsafeRead cs i_
535           d <- M.basicUnsafeRead ds i_
536           e <- M.basicUnsafeRead es i_
537           return (a, b, c, d, e)
538   {-# INLINE basicUnsafeWrite  #-}
539   basicUnsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
540       = do
541           M.basicUnsafeWrite as i_ a
542           M.basicUnsafeWrite bs i_ b
543           M.basicUnsafeWrite cs i_ c
544           M.basicUnsafeWrite ds i_ d
545           M.basicUnsafeWrite es i_ e
546   {-# INLINE basicClear  #-}
547   basicClear (MV_5 n_ as bs cs ds es)
548       = do
549           M.basicClear as
550           M.basicClear bs
551           M.basicClear cs
552           M.basicClear ds
553           M.basicClear es
554   {-# INLINE basicSet  #-}
555   basicSet (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
556       = do
557           M.basicSet as a
558           M.basicSet bs b
559           M.basicSet cs c
560           M.basicSet ds d
561           M.basicSet es e
562   {-# INLINE basicUnsafeCopy  #-}
563   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
564                                                            bs2
565                                                            cs2
566                                                            ds2
567                                                            es2)
568       = do
569           M.basicUnsafeCopy as1 as2
570           M.basicUnsafeCopy bs1 bs2
571           M.basicUnsafeCopy cs1 cs2
572           M.basicUnsafeCopy ds1 ds2
573           M.basicUnsafeCopy es1 es2
574   {-# INLINE basicUnsafeGrow  #-}
575   basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
576       = do
577           as' <- M.basicUnsafeGrow as m_
578           bs' <- M.basicUnsafeGrow bs m_
579           cs' <- M.basicUnsafeGrow cs m_
580           ds' <- M.basicUnsafeGrow ds m_
581           es' <- M.basicUnsafeGrow es m_
582           return $ MV_5 (m_+n_) as' bs' cs' ds' es'
583 instance (Unbox a,
584           Unbox b,
585           Unbox c,
586           Unbox d,
587           Unbox e) => G.Vector Vector (a, b, c, d, e) where
588   {-# INLINE basicUnsafeFreeze  #-}
589   basicUnsafeFreeze (MV_5 n_ as bs cs ds es)
590       = do
591           as' <- G.basicUnsafeFreeze as
592           bs' <- G.basicUnsafeFreeze bs
593           cs' <- G.basicUnsafeFreeze cs
594           ds' <- G.basicUnsafeFreeze ds
595           es' <- G.basicUnsafeFreeze es
596           return $ V_5 n_ as' bs' cs' ds' es'
597   {-# INLINE basicLength  #-}
598   basicLength (V_5 n_ as bs cs ds es) = n_
599   {-# INLINE basicUnsafeSlice  #-}
600   basicUnsafeSlice i_ m_ (V_5 n_ as bs cs ds es)
601       = V_5 m_ (G.basicUnsafeSlice i_ m_ as)
602                (G.basicUnsafeSlice i_ m_ bs)
603                (G.basicUnsafeSlice i_ m_ cs)
604                (G.basicUnsafeSlice i_ m_ ds)
605                (G.basicUnsafeSlice i_ m_ es)
606   {-# INLINE basicUnsafeIndexM  #-}
607   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
608       = do
609           a <- G.basicUnsafeIndexM as i_
610           b <- G.basicUnsafeIndexM bs i_
611           c <- G.basicUnsafeIndexM cs i_
612           d <- G.basicUnsafeIndexM ds i_
613           e <- G.basicUnsafeIndexM es i_
614           return (a, b, c, d, e)
615   {-# INLINE basicUnsafeCopy  #-}
616   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (V_5 n_2 as2
617                                                           bs2
618                                                           cs2
619                                                           ds2
620                                                           es2)
621       = do
622           G.basicUnsafeCopy as1 as2
623           G.basicUnsafeCopy bs1 bs2
624           G.basicUnsafeCopy cs1 cs2
625           G.basicUnsafeCopy ds1 ds2
626           G.basicUnsafeCopy es1 es2
627   {-# INLINE elemseq  #-}
628   elemseq _ (a, b, c, d, e)
629       = G.elemseq (undefined :: Vector a) a
630         . G.elemseq (undefined :: Vector b) b
631         . G.elemseq (undefined :: Vector c) c
632         . G.elemseq (undefined :: Vector d) d
633         . G.elemseq (undefined :: Vector e) e
634 #endif
635 #ifdef DEFINE_MUTABLE
636 -- | /O(1)/ Zip 5 vectors
637 zip5 :: (Unbox a,
638          Unbox b,
639          Unbox c,
640          Unbox d,
641          Unbox e) => MVector s a ->
642                      MVector s b ->
643                      MVector s c ->
644                      MVector s d ->
645                      MVector s e -> MVector s (a, b, c, d, e)
646 {-# INLINE_STREAM zip5 #-}
647 zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as)
648                                (unsafeSlice 0 len bs)
649                                (unsafeSlice 0 len cs)
650                                (unsafeSlice 0 len ds)
651                                (unsafeSlice 0 len es)
652   where
653     len = length as `min`
654           length bs `min`
655           length cs `min`
656           length ds `min`
657           length es
658 -- | /O(1)/ Unzip 5 vectors
659 unzip5 :: (Unbox a,
660            Unbox b,
661            Unbox c,
662            Unbox d,
663            Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
664                                                      MVector s b,
665                                                      MVector s c,
666                                                      MVector s d,
667                                                      MVector s e)
668 {-# INLINE unzip5 #-}
669 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
670 #endif
671 #ifdef DEFINE_IMMUTABLE
672 -- | /O(1)/ Zip 5 vectors
673 zip5 :: (Unbox a,
674          Unbox b,
675          Unbox c,
676          Unbox d,
677          Unbox e) => Vector a ->
678                      Vector b ->
679                      Vector c ->
680                      Vector d ->
681                      Vector e -> Vector (a, b, c, d, e)
682 {-# INLINE_STREAM zip5 #-}
683 zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
684                               (unsafeSlice 0 len bs)
685                               (unsafeSlice 0 len cs)
686                               (unsafeSlice 0 len ds)
687                               (unsafeSlice 0 len es)
688   where
689     len = length as `min`
690           length bs `min`
691           length cs `min`
692           length ds `min`
693           length es
694 {-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
695   G.stream (zip5 as
696                  bs
697                  cs
698                  ds
699                  es) = Stream.zipWith5 (, , , ,) (G.stream as)
700                                                  (G.stream bs)
701                                                  (G.stream cs)
702                                                  (G.stream ds)
703                                                  (G.stream es)
704   #-}
705 -- | /O(1)/ Unzip 5 vectors
706 unzip5 :: (Unbox a,
707            Unbox b,
708            Unbox c,
709            Unbox d,
710            Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
711                                                   Vector b,
712                                                   Vector c,
713                                                   Vector d,
714                                                   Vector e)
715 {-# INLINE unzip5 #-}
716 unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
717 #endif
718 #ifdef DEFINE_INSTANCES
719 data instance MVector s (a, b, c, d, e, f)
720     = MV_6 {-# UNPACK #-} !Int !(MVector s a)
721                                !(MVector s b)
722                                !(MVector s c)
723                                !(MVector s d)
724                                !(MVector s e)
725                                !(MVector s f)
726 data instance Vector (a, b, c, d, e, f)
727     = V_6 {-# UNPACK #-} !Int !(Vector a)
728                               !(Vector b)
729                               !(Vector c)
730                               !(Vector d)
731                               !(Vector e)
732                               !(Vector f)
733 instance (Unbox a,
734           Unbox b,
735           Unbox c,
736           Unbox d,
737           Unbox e,
738           Unbox f) => Unbox (a, b, c, d, e, f)
739 instance (Unbox a,
740           Unbox b,
741           Unbox c,
742           Unbox d,
743           Unbox e,
744           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
745   {-# INLINE basicLength  #-}
746   basicLength (MV_6 n_ as bs cs ds es fs) = n_
747   {-# INLINE basicUnsafeSlice  #-}
748   basicUnsafeSlice i_ m_ (MV_6 n_ as bs cs ds es fs)
749       = MV_6 m_ (M.basicUnsafeSlice i_ m_ as)
750                 (M.basicUnsafeSlice i_ m_ bs)
751                 (M.basicUnsafeSlice i_ m_ cs)
752                 (M.basicUnsafeSlice i_ m_ ds)
753                 (M.basicUnsafeSlice i_ m_ es)
754                 (M.basicUnsafeSlice i_ m_ fs)
755   {-# INLINE basicOverlaps  #-}
756   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
757                                                              bs2
758                                                              cs2
759                                                              ds2
760                                                              es2
761                                                              fs2)
762       = M.basicOverlaps as1 as2
763         || M.basicOverlaps bs1 bs2
764         || M.basicOverlaps cs1 cs2
765         || M.basicOverlaps ds1 ds2
766         || M.basicOverlaps es1 es2
767         || M.basicOverlaps fs1 fs2
768   {-# INLINE basicUnsafeNew  #-}
769   basicUnsafeNew n_
770       = do
771           as <- M.basicUnsafeNew n_
772           bs <- M.basicUnsafeNew n_
773           cs <- M.basicUnsafeNew n_
774           ds <- M.basicUnsafeNew n_
775           es <- M.basicUnsafeNew n_
776           fs <- M.basicUnsafeNew n_
777           return $ MV_6 n_ as bs cs ds es fs
778   {-# INLINE basicUnsafeReplicate  #-}
779   basicUnsafeReplicate n_ (a, b, c, d, e, f)
780       = do
781           as <- M.basicUnsafeReplicate n_ a
782           bs <- M.basicUnsafeReplicate n_ b
783           cs <- M.basicUnsafeReplicate n_ c
784           ds <- M.basicUnsafeReplicate n_ d
785           es <- M.basicUnsafeReplicate n_ e
786           fs <- M.basicUnsafeReplicate n_ f
787           return $ MV_6 n_ as bs cs ds es fs
788   {-# INLINE basicUnsafeRead  #-}
789   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
790       = do
791           a <- M.basicUnsafeRead as i_
792           b <- M.basicUnsafeRead bs i_
793           c <- M.basicUnsafeRead cs i_
794           d <- M.basicUnsafeRead ds i_
795           e <- M.basicUnsafeRead es i_
796           f <- M.basicUnsafeRead fs i_
797           return (a, b, c, d, e, f)
798   {-# INLINE basicUnsafeWrite  #-}
799   basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
800       = do
801           M.basicUnsafeWrite as i_ a
802           M.basicUnsafeWrite bs i_ b
803           M.basicUnsafeWrite cs i_ c
804           M.basicUnsafeWrite ds i_ d
805           M.basicUnsafeWrite es i_ e
806           M.basicUnsafeWrite fs i_ f
807   {-# INLINE basicClear  #-}
808   basicClear (MV_6 n_ as bs cs ds es fs)
809       = do
810           M.basicClear as
811           M.basicClear bs
812           M.basicClear cs
813           M.basicClear ds
814           M.basicClear es
815           M.basicClear fs
816   {-# INLINE basicSet  #-}
817   basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
818       = do
819           M.basicSet as a
820           M.basicSet bs b
821           M.basicSet cs c
822           M.basicSet ds d
823           M.basicSet es e
824           M.basicSet fs f
825   {-# INLINE basicUnsafeCopy  #-}
826   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
827                                                                bs2
828                                                                cs2
829                                                                ds2
830                                                                es2
831                                                                fs2)
832       = do
833           M.basicUnsafeCopy as1 as2
834           M.basicUnsafeCopy bs1 bs2
835           M.basicUnsafeCopy cs1 cs2
836           M.basicUnsafeCopy ds1 ds2
837           M.basicUnsafeCopy es1 es2
838           M.basicUnsafeCopy fs1 fs2
839   {-# INLINE basicUnsafeGrow  #-}
840   basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
841       = do
842           as' <- M.basicUnsafeGrow as m_
843           bs' <- M.basicUnsafeGrow bs m_
844           cs' <- M.basicUnsafeGrow cs m_
845           ds' <- M.basicUnsafeGrow ds m_
846           es' <- M.basicUnsafeGrow es m_
847           fs' <- M.basicUnsafeGrow fs m_
848           return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs'
849 instance (Unbox a,
850           Unbox b,
851           Unbox c,
852           Unbox d,
853           Unbox e,
854           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
855   {-# INLINE basicUnsafeFreeze  #-}
856   basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs)
857       = do
858           as' <- G.basicUnsafeFreeze as
859           bs' <- G.basicUnsafeFreeze bs
860           cs' <- G.basicUnsafeFreeze cs
861           ds' <- G.basicUnsafeFreeze ds
862           es' <- G.basicUnsafeFreeze es
863           fs' <- G.basicUnsafeFreeze fs
864           return $ V_6 n_ as' bs' cs' ds' es' fs'
865   {-# INLINE basicLength  #-}
866   basicLength (V_6 n_ as bs cs ds es fs) = n_
867   {-# INLINE basicUnsafeSlice  #-}
868   basicUnsafeSlice i_ m_ (V_6 n_ as bs cs ds es fs)
869       = V_6 m_ (G.basicUnsafeSlice i_ m_ as)
870                (G.basicUnsafeSlice i_ m_ bs)
871                (G.basicUnsafeSlice i_ m_ cs)
872                (G.basicUnsafeSlice i_ m_ ds)
873                (G.basicUnsafeSlice i_ m_ es)
874                (G.basicUnsafeSlice i_ m_ fs)
875   {-# INLINE basicUnsafeIndexM  #-}
876   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
877       = do
878           a <- G.basicUnsafeIndexM as i_
879           b <- G.basicUnsafeIndexM bs i_
880           c <- G.basicUnsafeIndexM cs i_
881           d <- G.basicUnsafeIndexM ds i_
882           e <- G.basicUnsafeIndexM es i_
883           f <- G.basicUnsafeIndexM fs i_
884           return (a, b, c, d, e, f)
885   {-# INLINE basicUnsafeCopy  #-}
886   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (V_6 n_2 as2
887                                                               bs2
888                                                               cs2
889                                                               ds2
890                                                               es2
891                                                               fs2)
892       = do
893           G.basicUnsafeCopy as1 as2
894           G.basicUnsafeCopy bs1 bs2
895           G.basicUnsafeCopy cs1 cs2
896           G.basicUnsafeCopy ds1 ds2
897           G.basicUnsafeCopy es1 es2
898           G.basicUnsafeCopy fs1 fs2
899   {-# INLINE elemseq  #-}
900   elemseq _ (a, b, c, d, e, f)
901       = G.elemseq (undefined :: Vector a) a
902         . G.elemseq (undefined :: Vector b) b
903         . G.elemseq (undefined :: Vector c) c
904         . G.elemseq (undefined :: Vector d) d
905         . G.elemseq (undefined :: Vector e) e
906         . G.elemseq (undefined :: Vector f) f
907 #endif
908 #ifdef DEFINE_MUTABLE
909 -- | /O(1)/ Zip 6 vectors
910 zip6 :: (Unbox a,
911          Unbox b,
912          Unbox c,
913          Unbox d,
914          Unbox e,
915          Unbox f) => MVector s a ->
916                      MVector s b ->
917                      MVector s c ->
918                      MVector s d ->
919                      MVector s e ->
920                      MVector s f -> MVector s (a, b, c, d, e, f)
921 {-# INLINE_STREAM zip6 #-}
922 zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
923                                   (unsafeSlice 0 len bs)
924                                   (unsafeSlice 0 len cs)
925                                   (unsafeSlice 0 len ds)
926                                   (unsafeSlice 0 len es)
927                                   (unsafeSlice 0 len fs)
928   where
929     len = length as `min`
930           length bs `min`
931           length cs `min`
932           length ds `min`
933           length es `min`
934           length fs
935 -- | /O(1)/ Unzip 6 vectors
936 unzip6 :: (Unbox a,
937            Unbox b,
938            Unbox c,
939            Unbox d,
940            Unbox e,
941            Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
942                                                         MVector s b,
943                                                         MVector s c,
944                                                         MVector s d,
945                                                         MVector s e,
946                                                         MVector s f)
947 {-# INLINE unzip6 #-}
948 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
949 #endif
950 #ifdef DEFINE_IMMUTABLE
951 -- | /O(1)/ Zip 6 vectors
952 zip6 :: (Unbox a,
953          Unbox b,
954          Unbox c,
955          Unbox d,
956          Unbox e,
957          Unbox f) => Vector a ->
958                      Vector b ->
959                      Vector c ->
960                      Vector d ->
961                      Vector e ->
962                      Vector f -> Vector (a, b, c, d, e, f)
963 {-# INLINE_STREAM zip6 #-}
964 zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
965                                  (unsafeSlice 0 len bs)
966                                  (unsafeSlice 0 len cs)
967                                  (unsafeSlice 0 len ds)
968                                  (unsafeSlice 0 len es)
969                                  (unsafeSlice 0 len fs)
970   where
971     len = length as `min`
972           length bs `min`
973           length cs `min`
974           length ds `min`
975           length es `min`
976           length fs
977 {-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
978   G.stream (zip6 as
979                  bs
980                  cs
981                  ds
982                  es
983                  fs) = Stream.zipWith6 (, , , , ,) (G.stream as)
984                                                    (G.stream bs)
985                                                    (G.stream cs)
986                                                    (G.stream ds)
987                                                    (G.stream es)
988                                                    (G.stream fs)
989   #-}
990 -- | /O(1)/ Unzip 6 vectors
991 unzip6 :: (Unbox a,
992            Unbox b,
993            Unbox c,
994            Unbox d,
995            Unbox e,
996            Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
997                                                      Vector b,
998                                                      Vector c,
999                                                      Vector d,
1000                                                      Vector e,
1001                                                      Vector f)
1002 {-# INLINE unzip6 #-}
1003 unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
1004 #endif