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