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