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