Add basicUnsafeMove to generation script and regenerate unbox-tuble-instances
[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 basicUnsafeMove  #-}
617   basicUnsafeMove (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
618                                                            bs2
619                                                            cs2
620                                                            ds2
621                                                            es2)
622       = do
623           M.basicUnsafeMove as1 as2
624           M.basicUnsafeMove bs1 bs2
625           M.basicUnsafeMove cs1 cs2
626           M.basicUnsafeMove ds1 ds2
627           M.basicUnsafeMove es1 es2
628   {-# INLINE basicUnsafeGrow  #-}
629   basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
630       = do
631           as' <- M.basicUnsafeGrow as m_
632           bs' <- M.basicUnsafeGrow bs m_
633           cs' <- M.basicUnsafeGrow cs m_
634           ds' <- M.basicUnsafeGrow ds m_
635           es' <- M.basicUnsafeGrow es m_
636           return $ MV_5 (m_+n_) as' bs' cs' ds' es'
637 instance (Unbox a,
638           Unbox b,
639           Unbox c,
640           Unbox d,
641           Unbox e) => G.Vector Vector (a, b, c, d, e) where
642   {-# INLINE basicUnsafeFreeze  #-}
643   basicUnsafeFreeze (MV_5 n_ as bs cs ds es)
644       = do
645           as' <- G.basicUnsafeFreeze as
646           bs' <- G.basicUnsafeFreeze bs
647           cs' <- G.basicUnsafeFreeze cs
648           ds' <- G.basicUnsafeFreeze ds
649           es' <- G.basicUnsafeFreeze es
650           return $ V_5 n_ as' bs' cs' ds' es'
651   {-# INLINE basicUnsafeThaw  #-}
652   basicUnsafeThaw (V_5 n_ as bs cs ds es)
653       = do
654           as' <- G.basicUnsafeThaw as
655           bs' <- G.basicUnsafeThaw bs
656           cs' <- G.basicUnsafeThaw cs
657           ds' <- G.basicUnsafeThaw ds
658           es' <- G.basicUnsafeThaw es
659           return $ MV_5 n_ as' bs' cs' ds' es'
660   {-# INLINE basicLength  #-}
661   basicLength (V_5 n_ as bs cs ds es) = n_
662   {-# INLINE basicUnsafeSlice  #-}
663   basicUnsafeSlice i_ m_ (V_5 n_ as bs cs ds es)
664       = V_5 m_ (G.basicUnsafeSlice i_ m_ as)
665                (G.basicUnsafeSlice i_ m_ bs)
666                (G.basicUnsafeSlice i_ m_ cs)
667                (G.basicUnsafeSlice i_ m_ ds)
668                (G.basicUnsafeSlice i_ m_ es)
669   {-# INLINE basicUnsafeIndexM  #-}
670   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
671       = do
672           a <- G.basicUnsafeIndexM as i_
673           b <- G.basicUnsafeIndexM bs i_
674           c <- G.basicUnsafeIndexM cs i_
675           d <- G.basicUnsafeIndexM ds i_
676           e <- G.basicUnsafeIndexM es i_
677           return (a, b, c, d, e)
678   {-# INLINE basicUnsafeCopy  #-}
679   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (V_5 n_2 as2
680                                                           bs2
681                                                           cs2
682                                                           ds2
683                                                           es2)
684       = do
685           G.basicUnsafeCopy as1 as2
686           G.basicUnsafeCopy bs1 bs2
687           G.basicUnsafeCopy cs1 cs2
688           G.basicUnsafeCopy ds1 ds2
689           G.basicUnsafeCopy es1 es2
690   {-# INLINE elemseq  #-}
691   elemseq _ (a, b, c, d, e)
692       = G.elemseq (undefined :: Vector a) a
693         . G.elemseq (undefined :: Vector b) b
694         . G.elemseq (undefined :: Vector c) c
695         . G.elemseq (undefined :: Vector d) d
696         . G.elemseq (undefined :: Vector e) e
697 #endif
698 #ifdef DEFINE_MUTABLE
699 -- | /O(1)/ Zip 5 vectors
700 zip5 :: (Unbox a,
701          Unbox b,
702          Unbox c,
703          Unbox d,
704          Unbox e) => MVector s a ->
705                      MVector s b ->
706                      MVector s c ->
707                      MVector s d ->
708                      MVector s e -> MVector s (a, b, c, d, e)
709 {-# INLINE_STREAM zip5 #-}
710 zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as)
711                                (unsafeSlice 0 len bs)
712                                (unsafeSlice 0 len cs)
713                                (unsafeSlice 0 len ds)
714                                (unsafeSlice 0 len es)
715   where
716     len = length as `min`
717           length bs `min`
718           length cs `min`
719           length ds `min`
720           length es
721 -- | /O(1)/ Unzip 5 vectors
722 unzip5 :: (Unbox a,
723            Unbox b,
724            Unbox c,
725            Unbox d,
726            Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
727                                                      MVector s b,
728                                                      MVector s c,
729                                                      MVector s d,
730                                                      MVector s e)
731 {-# INLINE unzip5 #-}
732 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
733 #endif
734 #ifdef DEFINE_IMMUTABLE
735 -- | /O(1)/ Zip 5 vectors
736 zip5 :: (Unbox a,
737          Unbox b,
738          Unbox c,
739          Unbox d,
740          Unbox e) => Vector a ->
741                      Vector b ->
742                      Vector c ->
743                      Vector d ->
744                      Vector e -> Vector (a, b, c, d, e)
745 {-# INLINE_STREAM zip5 #-}
746 zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
747                               (unsafeSlice 0 len bs)
748                               (unsafeSlice 0 len cs)
749                               (unsafeSlice 0 len ds)
750                               (unsafeSlice 0 len es)
751   where
752     len = length as `min`
753           length bs `min`
754           length cs `min`
755           length ds `min`
756           length es
757 {-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
758   G.stream (zip5 as
759                  bs
760                  cs
761                  ds
762                  es) = Stream.zipWith5 (, , , ,) (G.stream as)
763                                                  (G.stream bs)
764                                                  (G.stream cs)
765                                                  (G.stream ds)
766                                                  (G.stream es)
767   #-}
768 -- | /O(1)/ Unzip 5 vectors
769 unzip5 :: (Unbox a,
770            Unbox b,
771            Unbox c,
772            Unbox d,
773            Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
774                                                   Vector b,
775                                                   Vector c,
776                                                   Vector d,
777                                                   Vector e)
778 {-# INLINE unzip5 #-}
779 unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
780 #endif
781 #ifdef DEFINE_INSTANCES
782 data instance MVector s (a, b, c, d, e, f)
783     = MV_6 {-# UNPACK #-} !Int !(MVector s a)
784                                !(MVector s b)
785                                !(MVector s c)
786                                !(MVector s d)
787                                !(MVector s e)
788                                !(MVector s f)
789 data instance Vector (a, b, c, d, e, f)
790     = V_6 {-# UNPACK #-} !Int !(Vector a)
791                               !(Vector b)
792                               !(Vector c)
793                               !(Vector d)
794                               !(Vector e)
795                               !(Vector f)
796 instance (Unbox a,
797           Unbox b,
798           Unbox c,
799           Unbox d,
800           Unbox e,
801           Unbox f) => Unbox (a, b, c, d, e, f)
802 instance (Unbox a,
803           Unbox b,
804           Unbox c,
805           Unbox d,
806           Unbox e,
807           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
808   {-# INLINE basicLength  #-}
809   basicLength (MV_6 n_ as bs cs ds es fs) = n_
810   {-# INLINE basicUnsafeSlice  #-}
811   basicUnsafeSlice i_ m_ (MV_6 n_ as bs cs ds es fs)
812       = MV_6 m_ (M.basicUnsafeSlice i_ m_ as)
813                 (M.basicUnsafeSlice i_ m_ bs)
814                 (M.basicUnsafeSlice i_ m_ cs)
815                 (M.basicUnsafeSlice i_ m_ ds)
816                 (M.basicUnsafeSlice i_ m_ es)
817                 (M.basicUnsafeSlice i_ m_ fs)
818   {-# INLINE basicOverlaps  #-}
819   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
820                                                              bs2
821                                                              cs2
822                                                              ds2
823                                                              es2
824                                                              fs2)
825       = M.basicOverlaps as1 as2
826         || M.basicOverlaps bs1 bs2
827         || M.basicOverlaps cs1 cs2
828         || M.basicOverlaps ds1 ds2
829         || M.basicOverlaps es1 es2
830         || M.basicOverlaps fs1 fs2
831   {-# INLINE basicUnsafeNew  #-}
832   basicUnsafeNew n_
833       = do
834           as <- M.basicUnsafeNew n_
835           bs <- M.basicUnsafeNew n_
836           cs <- M.basicUnsafeNew n_
837           ds <- M.basicUnsafeNew n_
838           es <- M.basicUnsafeNew n_
839           fs <- M.basicUnsafeNew n_
840           return $ MV_6 n_ as bs cs ds es fs
841   {-# INLINE basicUnsafeReplicate  #-}
842   basicUnsafeReplicate n_ (a, b, c, d, e, f)
843       = do
844           as <- M.basicUnsafeReplicate n_ a
845           bs <- M.basicUnsafeReplicate n_ b
846           cs <- M.basicUnsafeReplicate n_ c
847           ds <- M.basicUnsafeReplicate n_ d
848           es <- M.basicUnsafeReplicate n_ e
849           fs <- M.basicUnsafeReplicate n_ f
850           return $ MV_6 n_ as bs cs ds es fs
851   {-# INLINE basicUnsafeRead  #-}
852   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
853       = do
854           a <- M.basicUnsafeRead as i_
855           b <- M.basicUnsafeRead bs i_
856           c <- M.basicUnsafeRead cs i_
857           d <- M.basicUnsafeRead ds i_
858           e <- M.basicUnsafeRead es i_
859           f <- M.basicUnsafeRead fs i_
860           return (a, b, c, d, e, f)
861   {-# INLINE basicUnsafeWrite  #-}
862   basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
863       = do
864           M.basicUnsafeWrite as i_ a
865           M.basicUnsafeWrite bs i_ b
866           M.basicUnsafeWrite cs i_ c
867           M.basicUnsafeWrite ds i_ d
868           M.basicUnsafeWrite es i_ e
869           M.basicUnsafeWrite fs i_ f
870   {-# INLINE basicClear  #-}
871   basicClear (MV_6 n_ as bs cs ds es fs)
872       = do
873           M.basicClear as
874           M.basicClear bs
875           M.basicClear cs
876           M.basicClear ds
877           M.basicClear es
878           M.basicClear fs
879   {-# INLINE basicSet  #-}
880   basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
881       = do
882           M.basicSet as a
883           M.basicSet bs b
884           M.basicSet cs c
885           M.basicSet ds d
886           M.basicSet es e
887           M.basicSet fs f
888   {-# INLINE basicUnsafeCopy  #-}
889   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
890                                                                bs2
891                                                                cs2
892                                                                ds2
893                                                                es2
894                                                                fs2)
895       = do
896           M.basicUnsafeCopy as1 as2
897           M.basicUnsafeCopy bs1 bs2
898           M.basicUnsafeCopy cs1 cs2
899           M.basicUnsafeCopy ds1 ds2
900           M.basicUnsafeCopy es1 es2
901           M.basicUnsafeCopy fs1 fs2
902   {-# INLINE basicUnsafeMove  #-}
903   basicUnsafeMove (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
904                                                                bs2
905                                                                cs2
906                                                                ds2
907                                                                es2
908                                                                fs2)
909       = do
910           M.basicUnsafeMove as1 as2
911           M.basicUnsafeMove bs1 bs2
912           M.basicUnsafeMove cs1 cs2
913           M.basicUnsafeMove ds1 ds2
914           M.basicUnsafeMove es1 es2
915           M.basicUnsafeMove fs1 fs2
916   {-# INLINE basicUnsafeGrow  #-}
917   basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
918       = do
919           as' <- M.basicUnsafeGrow as m_
920           bs' <- M.basicUnsafeGrow bs m_
921           cs' <- M.basicUnsafeGrow cs m_
922           ds' <- M.basicUnsafeGrow ds m_
923           es' <- M.basicUnsafeGrow es m_
924           fs' <- M.basicUnsafeGrow fs m_
925           return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs'
926 instance (Unbox a,
927           Unbox b,
928           Unbox c,
929           Unbox d,
930           Unbox e,
931           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
932   {-# INLINE basicUnsafeFreeze  #-}
933   basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs)
934       = do
935           as' <- G.basicUnsafeFreeze as
936           bs' <- G.basicUnsafeFreeze bs
937           cs' <- G.basicUnsafeFreeze cs
938           ds' <- G.basicUnsafeFreeze ds
939           es' <- G.basicUnsafeFreeze es
940           fs' <- G.basicUnsafeFreeze fs
941           return $ V_6 n_ as' bs' cs' ds' es' fs'
942   {-# INLINE basicUnsafeThaw  #-}
943   basicUnsafeThaw (V_6 n_ as bs cs ds es fs)
944       = do
945           as' <- G.basicUnsafeThaw as
946           bs' <- G.basicUnsafeThaw bs
947           cs' <- G.basicUnsafeThaw cs
948           ds' <- G.basicUnsafeThaw ds
949           es' <- G.basicUnsafeThaw es
950           fs' <- G.basicUnsafeThaw fs
951           return $ MV_6 n_ as' bs' cs' ds' es' fs'
952   {-# INLINE basicLength  #-}
953   basicLength (V_6 n_ as bs cs ds es fs) = n_
954   {-# INLINE basicUnsafeSlice  #-}
955   basicUnsafeSlice i_ m_ (V_6 n_ as bs cs ds es fs)
956       = V_6 m_ (G.basicUnsafeSlice i_ m_ as)
957                (G.basicUnsafeSlice i_ m_ bs)
958                (G.basicUnsafeSlice i_ m_ cs)
959                (G.basicUnsafeSlice i_ m_ ds)
960                (G.basicUnsafeSlice i_ m_ es)
961                (G.basicUnsafeSlice i_ m_ fs)
962   {-# INLINE basicUnsafeIndexM  #-}
963   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
964       = do
965           a <- G.basicUnsafeIndexM as i_
966           b <- G.basicUnsafeIndexM bs i_
967           c <- G.basicUnsafeIndexM cs i_
968           d <- G.basicUnsafeIndexM ds i_
969           e <- G.basicUnsafeIndexM es i_
970           f <- G.basicUnsafeIndexM fs i_
971           return (a, b, c, d, e, f)
972   {-# INLINE basicUnsafeCopy  #-}
973   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (V_6 n_2 as2
974                                                               bs2
975                                                               cs2
976                                                               ds2
977                                                               es2
978                                                               fs2)
979       = do
980           G.basicUnsafeCopy as1 as2
981           G.basicUnsafeCopy bs1 bs2
982           G.basicUnsafeCopy cs1 cs2
983           G.basicUnsafeCopy ds1 ds2
984           G.basicUnsafeCopy es1 es2
985           G.basicUnsafeCopy fs1 fs2
986   {-# INLINE elemseq  #-}
987   elemseq _ (a, b, c, d, e, f)
988       = G.elemseq (undefined :: Vector a) a
989         . G.elemseq (undefined :: Vector b) b
990         . G.elemseq (undefined :: Vector c) c
991         . G.elemseq (undefined :: Vector d) d
992         . G.elemseq (undefined :: Vector e) e
993         . G.elemseq (undefined :: Vector f) f
994 #endif
995 #ifdef DEFINE_MUTABLE
996 -- | /O(1)/ Zip 6 vectors
997 zip6 :: (Unbox a,
998          Unbox b,
999          Unbox c,
1000          Unbox d,
1001          Unbox e,
1002          Unbox f) => MVector s a ->
1003                      MVector s b ->
1004                      MVector s c ->
1005                      MVector s d ->
1006                      MVector s e ->
1007                      MVector s f -> MVector s (a, b, c, d, e, f)
1008 {-# INLINE_STREAM zip6 #-}
1009 zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
1010                                   (unsafeSlice 0 len bs)
1011                                   (unsafeSlice 0 len cs)
1012                                   (unsafeSlice 0 len ds)
1013                                   (unsafeSlice 0 len es)
1014                                   (unsafeSlice 0 len fs)
1015   where
1016     len = length as `min`
1017           length bs `min`
1018           length cs `min`
1019           length ds `min`
1020           length es `min`
1021           length fs
1022 -- | /O(1)/ Unzip 6 vectors
1023 unzip6 :: (Unbox a,
1024            Unbox b,
1025            Unbox c,
1026            Unbox d,
1027            Unbox e,
1028            Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
1029                                                         MVector s b,
1030                                                         MVector s c,
1031                                                         MVector s d,
1032                                                         MVector s e,
1033                                                         MVector s f)
1034 {-# INLINE unzip6 #-}
1035 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
1036 #endif
1037 #ifdef DEFINE_IMMUTABLE
1038 -- | /O(1)/ Zip 6 vectors
1039 zip6 :: (Unbox a,
1040          Unbox b,
1041          Unbox c,
1042          Unbox d,
1043          Unbox e,
1044          Unbox f) => Vector a ->
1045                      Vector b ->
1046                      Vector c ->
1047                      Vector d ->
1048                      Vector e ->
1049                      Vector f -> Vector (a, b, c, d, e, f)
1050 {-# INLINE_STREAM zip6 #-}
1051 zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
1052                                  (unsafeSlice 0 len bs)
1053                                  (unsafeSlice 0 len cs)
1054                                  (unsafeSlice 0 len ds)
1055                                  (unsafeSlice 0 len es)
1056                                  (unsafeSlice 0 len fs)
1057   where
1058     len = length as `min`
1059           length bs `min`
1060           length cs `min`
1061           length ds `min`
1062           length es `min`
1063           length fs
1064 {-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
1065   G.stream (zip6 as
1066                  bs
1067                  cs
1068                  ds
1069                  es
1070                  fs) = Stream.zipWith6 (, , , , ,) (G.stream as)
1071                                                    (G.stream bs)
1072                                                    (G.stream cs)
1073                                                    (G.stream ds)
1074                                                    (G.stream es)
1075                                                    (G.stream fs)
1076   #-}
1077 -- | /O(1)/ Unzip 6 vectors
1078 unzip6 :: (Unbox a,
1079            Unbox b,
1080            Unbox c,
1081            Unbox d,
1082            Unbox e,
1083            Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
1084                                                      Vector b,
1085                                                      Vector c,
1086                                                      Vector d,
1087                                                      Vector e,
1088                                                      Vector f)
1089 {-# INLINE unzip6 #-}
1090 unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
1091 #endif