EXPERIMENTAL: Unboxing infrastructure
[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   {-# INLINE elemseq  #-}
84   elemseq _ (a, b) x_
85       = G.elemseq (undefined :: Vector a) a $
86         G.elemseq (undefined :: Vector b) b $ x_
87 #endif
88 #ifdef DEFINE_MUTABLE
89 zip :: (Unbox a, Unbox b) => MVector s a ->
90                              MVector s b -> MVector s (a, b)
91 {-# INLINE_STREAM zip #-}
92 zip as bs = MV_2 len (unsafeSlice as 0 len) (unsafeSlice bs 0 len)
93   where len = length as `min` length bs
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 [Vector.Unboxed]" 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   {-# INLINE elemseq  #-}
215   elemseq _ (a, b, c) x_
216       = G.elemseq (undefined :: Vector a) a $
217         G.elemseq (undefined :: Vector b) b $
218         G.elemseq (undefined :: Vector c) c $ x_
219 #endif
220 #ifdef DEFINE_MUTABLE
221 zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
222                                        MVector s b ->
223                                        MVector s c -> MVector s (a, b, c)
224 {-# INLINE_STREAM zip3 #-}
225 zip3 as bs cs = MV_3 len (unsafeSlice as 0 len)
226                          (unsafeSlice bs 0 len)
227                          (unsafeSlice cs 0 len)
228   where len = length as `min` length bs `min` length cs
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 [Vector.Unboxed]" 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   {-# INLINE elemseq  #-}
379   elemseq _ (a, b, c, d) x_
380       = G.elemseq (undefined :: Vector a) a $
381         G.elemseq (undefined :: Vector b) b $
382         G.elemseq (undefined :: Vector c) c $
383         G.elemseq (undefined :: Vector d) d $ x_
384 #endif
385 #ifdef DEFINE_MUTABLE
386 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
387                                                 MVector s b ->
388                                                 MVector s c ->
389                                                 MVector s d -> MVector s (a, b, c, d)
390 {-# INLINE_STREAM zip4 #-}
391 zip4 as bs cs ds = MV_4 len (unsafeSlice as 0 len)
392                             (unsafeSlice bs 0 len)
393                             (unsafeSlice cs 0 len)
394                             (unsafeSlice ds 0 len)
395   where
396     len = length as `min` length bs `min` length cs `min` length ds
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 [Vector.Unboxed]" 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   {-# INLINE elemseq  #-}
583   elemseq _ (a, b, c, d, e) x_
584       = G.elemseq (undefined :: Vector a) a $
585         G.elemseq (undefined :: Vector b) b $
586         G.elemseq (undefined :: Vector c) c $
587         G.elemseq (undefined :: Vector d) d $
588         G.elemseq (undefined :: Vector e) e $ x_
589 #endif
590 #ifdef DEFINE_MUTABLE
591 zip5 :: (Unbox a,
592          Unbox b,
593          Unbox c,
594          Unbox d,
595          Unbox e) => MVector s a ->
596                      MVector s b ->
597                      MVector s c ->
598                      MVector s d ->
599                      MVector s e -> MVector s (a, b, c, d, e)
600 {-# INLINE_STREAM zip5 #-}
601 zip5 as bs cs ds es = MV_5 len (unsafeSlice as 0 len)
602                                (unsafeSlice bs 0 len)
603                                (unsafeSlice cs 0 len)
604                                (unsafeSlice ds 0 len)
605                                (unsafeSlice es 0 len)
606   where
607     len = length as `min`
608           length bs `min`
609           length cs `min`
610           length ds `min`
611           length es
612 unzip5 :: (Unbox a,
613            Unbox b,
614            Unbox c,
615            Unbox d,
616            Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
617                                                      MVector s b,
618                                                      MVector s c,
619                                                      MVector s d,
620                                                      MVector s e)
621 {-# INLINE unzip5 #-}
622 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
623 #endif
624 #ifdef DEFINE_IMMUTABLE
625 zip5 :: (Unbox a,
626          Unbox b,
627          Unbox c,
628          Unbox d,
629          Unbox e) => Vector a ->
630                      Vector b ->
631                      Vector c ->
632                      Vector d ->
633                      Vector e -> Vector (a, b, c, d, e)
634 {-# INLINE_STREAM zip5 #-}
635 zip5 as bs cs ds es = V_5 len (unsafeSlice as 0 len)
636                               (unsafeSlice bs 0 len)
637                               (unsafeSlice cs 0 len)
638                               (unsafeSlice ds 0 len)
639                               (unsafeSlice es 0 len)
640   where
641     len = length as `min`
642           length bs `min`
643           length cs `min`
644           length ds `min`
645           length es
646 {-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
647   G.stream (zip5 as
648                  bs
649                  cs
650                  ds
651                  es) = Stream.zipWith5 (, , , ,) (G.stream as)
652                                                  (G.stream bs)
653                                                  (G.stream cs)
654                                                  (G.stream ds)
655                                                  (G.stream es)
656   #-}
657 unzip5 :: (Unbox a,
658            Unbox b,
659            Unbox c,
660            Unbox d,
661            Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
662                                                   Vector b,
663                                                   Vector c,
664                                                   Vector d,
665                                                   Vector e)
666 {-# INLINE unzip5 #-}
667 unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
668 #endif
669 #ifdef DEFINE_INSTANCES
670 data instance MVector s (a, b, c, d, e, f)
671     = MV_6 {-# UNPACK #-} !Int !(MVector s a)
672                                !(MVector s b)
673                                !(MVector s c)
674                                !(MVector s d)
675                                !(MVector s e)
676                                !(MVector s f)
677 data instance Vector (a, b, c, d, e, f)
678     = V_6 {-# UNPACK #-} !Int !(Vector a)
679                               !(Vector b)
680                               !(Vector c)
681                               !(Vector d)
682                               !(Vector e)
683                               !(Vector f)
684 instance (Unbox a,
685           Unbox b,
686           Unbox c,
687           Unbox d,
688           Unbox e,
689           Unbox f) => Unbox (a, b, c, d, e, f)
690 instance (Unbox a,
691           Unbox b,
692           Unbox c,
693           Unbox d,
694           Unbox e,
695           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
696   {-# INLINE basicLength  #-}
697   basicLength (MV_6 n_ as bs cs ds es fs) = n_
698   {-# INLINE basicUnsafeSlice  #-}
699   basicUnsafeSlice (MV_6 n_ as bs cs ds es fs) i_ m_
700       = MV_6 m_ (M.basicUnsafeSlice as i_ m_)
701                 (M.basicUnsafeSlice bs i_ m_)
702                 (M.basicUnsafeSlice cs i_ m_)
703                 (M.basicUnsafeSlice ds i_ m_)
704                 (M.basicUnsafeSlice es i_ m_)
705                 (M.basicUnsafeSlice fs i_ m_)
706   {-# INLINE basicOverlaps  #-}
707   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
708                                                              bs2
709                                                              cs2
710                                                              ds2
711                                                              es2
712                                                              fs2)
713       = M.basicOverlaps as1 as2
714         || M.basicOverlaps bs1 bs2
715         || M.basicOverlaps cs1 cs2
716         || M.basicOverlaps ds1 ds2
717         || M.basicOverlaps es1 es2
718         || M.basicOverlaps fs1 fs2
719   {-# INLINE basicUnsafeNew  #-}
720   basicUnsafeNew n_
721       = do
722           as <- M.basicUnsafeNew n_
723           bs <- M.basicUnsafeNew n_
724           cs <- M.basicUnsafeNew n_
725           ds <- M.basicUnsafeNew n_
726           es <- M.basicUnsafeNew n_
727           fs <- M.basicUnsafeNew n_
728           return $ MV_6 n_ as bs cs ds es fs
729   {-# INLINE basicUnsafeNewWith  #-}
730   basicUnsafeNewWith n_ (a, b, c, d, e, f)
731       = do
732           as <- M.basicUnsafeNewWith n_ a
733           bs <- M.basicUnsafeNewWith n_ b
734           cs <- M.basicUnsafeNewWith n_ c
735           ds <- M.basicUnsafeNewWith n_ d
736           es <- M.basicUnsafeNewWith n_ e
737           fs <- M.basicUnsafeNewWith n_ f
738           return $ MV_6 n_ as bs cs ds es fs
739   {-# INLINE basicUnsafeRead  #-}
740   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
741       = do
742           a <- M.basicUnsafeRead as i_
743           b <- M.basicUnsafeRead bs i_
744           c <- M.basicUnsafeRead cs i_
745           d <- M.basicUnsafeRead ds i_
746           e <- M.basicUnsafeRead es i_
747           f <- M.basicUnsafeRead fs i_
748           return (a, b, c, d, e, f)
749   {-# INLINE basicUnsafeWrite  #-}
750   basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
751       = do
752           M.basicUnsafeWrite as i_ a
753           M.basicUnsafeWrite bs i_ b
754           M.basicUnsafeWrite cs i_ c
755           M.basicUnsafeWrite ds i_ d
756           M.basicUnsafeWrite es i_ e
757           M.basicUnsafeWrite fs i_ f
758   {-# INLINE basicClear  #-}
759   basicClear (MV_6 n_ as bs cs ds es fs)
760       = do
761           M.basicClear as
762           M.basicClear bs
763           M.basicClear cs
764           M.basicClear ds
765           M.basicClear es
766           M.basicClear fs
767   {-# INLINE basicSet  #-}
768   basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
769       = do
770           M.basicSet as a
771           M.basicSet bs b
772           M.basicSet cs c
773           M.basicSet ds d
774           M.basicSet es e
775           M.basicSet fs f
776   {-# INLINE basicUnsafeCopy  #-}
777   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
778                                                                bs2
779                                                                cs2
780                                                                ds2
781                                                                es2
782                                                                fs2)
783       = do
784           M.basicUnsafeCopy as1 as2
785           M.basicUnsafeCopy bs1 bs2
786           M.basicUnsafeCopy cs1 cs2
787           M.basicUnsafeCopy ds1 ds2
788           M.basicUnsafeCopy es1 es2
789           M.basicUnsafeCopy fs1 fs2
790   {-# INLINE basicUnsafeGrow  #-}
791   basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
792       = do
793           M.basicUnsafeGrow as m_
794           M.basicUnsafeGrow bs m_
795           M.basicUnsafeGrow cs m_
796           M.basicUnsafeGrow ds m_
797           M.basicUnsafeGrow es m_
798           M.basicUnsafeGrow fs m_
799           return $ MV_6 (m_+n_) as bs cs ds es fs
800 instance (Unbox a,
801           Unbox b,
802           Unbox c,
803           Unbox d,
804           Unbox e,
805           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
806   {-# INLINE unsafeFreeze  #-}
807   unsafeFreeze (MV_6 n_ as bs cs ds es fs)
808       = do
809           as' <- G.unsafeFreeze as
810           bs' <- G.unsafeFreeze bs
811           cs' <- G.unsafeFreeze cs
812           ds' <- G.unsafeFreeze ds
813           es' <- G.unsafeFreeze es
814           fs' <- G.unsafeFreeze fs
815           return $ V_6 n_ as' bs' cs' ds' es' fs'
816   {-# INLINE basicLength  #-}
817   basicLength (V_6 n_ as bs cs ds es fs) = n_
818   {-# INLINE basicUnsafeSlice  #-}
819   basicUnsafeSlice (V_6 n_ as bs cs ds es fs) i_ m_
820       = V_6 m_ (G.basicUnsafeSlice as i_ m_)
821                (G.basicUnsafeSlice bs i_ m_)
822                (G.basicUnsafeSlice cs i_ m_)
823                (G.basicUnsafeSlice ds i_ m_)
824                (G.basicUnsafeSlice es i_ m_)
825                (G.basicUnsafeSlice fs i_ m_)
826   {-# INLINE basicUnsafeIndexM  #-}
827   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
828       = do
829           a <- G.basicUnsafeIndexM as i_
830           b <- G.basicUnsafeIndexM bs i_
831           c <- G.basicUnsafeIndexM cs i_
832           d <- G.basicUnsafeIndexM ds i_
833           e <- G.basicUnsafeIndexM es i_
834           f <- G.basicUnsafeIndexM fs i_
835           return (a, b, c, d, e, f)
836   {-# INLINE elemseq  #-}
837   elemseq _ (a, b, c, d, e, f) x_
838       = G.elemseq (undefined :: Vector a) a $
839         G.elemseq (undefined :: Vector b) b $
840         G.elemseq (undefined :: Vector c) c $
841         G.elemseq (undefined :: Vector d) d $
842         G.elemseq (undefined :: Vector e) e $
843         G.elemseq (undefined :: Vector f) f $ x_
844 #endif
845 #ifdef DEFINE_MUTABLE
846 zip6 :: (Unbox a,
847          Unbox b,
848          Unbox c,
849          Unbox d,
850          Unbox e,
851          Unbox f) => MVector s a ->
852                      MVector s b ->
853                      MVector s c ->
854                      MVector s d ->
855                      MVector s e ->
856                      MVector s f -> MVector s (a, b, c, d, e, f)
857 {-# INLINE_STREAM zip6 #-}
858 zip6 as bs cs ds es fs = MV_6 len (unsafeSlice as 0 len)
859                                   (unsafeSlice bs 0 len)
860                                   (unsafeSlice cs 0 len)
861                                   (unsafeSlice ds 0 len)
862                                   (unsafeSlice es 0 len)
863                                   (unsafeSlice fs 0 len)
864   where
865     len = length as `min`
866           length bs `min`
867           length cs `min`
868           length ds `min`
869           length es `min`
870           length fs
871 unzip6 :: (Unbox a,
872            Unbox b,
873            Unbox c,
874            Unbox d,
875            Unbox e,
876            Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
877                                                         MVector s b,
878                                                         MVector s c,
879                                                         MVector s d,
880                                                         MVector s e,
881                                                         MVector s f)
882 {-# INLINE unzip6 #-}
883 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
884 #endif
885 #ifdef DEFINE_IMMUTABLE
886 zip6 :: (Unbox a,
887          Unbox b,
888          Unbox c,
889          Unbox d,
890          Unbox e,
891          Unbox f) => Vector a ->
892                      Vector b ->
893                      Vector c ->
894                      Vector d ->
895                      Vector e ->
896                      Vector f -> Vector (a, b, c, d, e, f)
897 {-# INLINE_STREAM zip6 #-}
898 zip6 as bs cs ds es fs = V_6 len (unsafeSlice as 0 len)
899                                  (unsafeSlice bs 0 len)
900                                  (unsafeSlice cs 0 len)
901                                  (unsafeSlice ds 0 len)
902                                  (unsafeSlice es 0 len)
903                                  (unsafeSlice fs 0 len)
904   where
905     len = length as `min`
906           length bs `min`
907           length cs `min`
908           length ds `min`
909           length es `min`
910           length fs
911 {-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
912   G.stream (zip6 as
913                  bs
914                  cs
915                  ds
916                  es
917                  fs) = Stream.zipWith6 (, , , , ,) (G.stream as)
918                                                    (G.stream bs)
919                                                    (G.stream cs)
920                                                    (G.stream ds)
921                                                    (G.stream es)
922                                                    (G.stream fs)
923   #-}
924 unzip6 :: (Unbox a,
925            Unbox b,
926            Unbox c,
927            Unbox d,
928            Unbox e,
929            Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
930                                                      Vector b,
931                                                      Vector c,
932                                                      Vector d,
933                                                      Vector e,
934                                                      Vector f)
935 {-# INLINE unzip6 #-}
936 unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
937 #endif