Finish Stream -> Bundle renaming
[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_FUSED zip #-}
109 zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
110   where len = length as `delayed_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_FUSED zip #-}
121 zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
122   where len = length as `delayed_min` length bs
123 {-# RULES "stream/zip [Vector.Unboxed]" forall as bs .
124   G.stream (zip as bs) = Bundle.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_FUSED 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
269     len = length as `delayed_min` length bs `delayed_min` length cs
270 -- | /O(1)/ Unzip 3 vectors
271 unzip3 :: (Unbox a,
272            Unbox b,
273            Unbox c) => MVector s (a, b, c) -> (MVector s a,
274                                                MVector s b,
275                                                MVector s c)
276 {-# INLINE unzip3 #-}
277 unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
278 #endif
279 #ifdef DEFINE_IMMUTABLE
280 -- | /O(1)/ Zip 3 vectors
281 zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
282                                        Vector b ->
283                                        Vector c -> Vector (a, b, c)
284 {-# INLINE_FUSED zip3 #-}
285 zip3 as bs cs = V_3 len (unsafeSlice 0 len as)
286                         (unsafeSlice 0 len bs)
287                         (unsafeSlice 0 len cs)
288   where
289     len = length as `delayed_min` length bs `delayed_min` length cs
290 {-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs .
291   G.stream (zip3 as bs cs) = Bundle.zipWith3 (, ,) (G.stream as)
292                                                    (G.stream bs)
293                                                    (G.stream cs)
294   #-}
295 -- | /O(1)/ Unzip 3 vectors
296 unzip3 :: (Unbox a,
297            Unbox b,
298            Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
299 {-# INLINE unzip3 #-}
300 unzip3 (V_3 n_ as bs cs) = (as, bs, cs)
301 #endif
302 #ifdef DEFINE_INSTANCES
303 data instance MVector s (a, b, c, d)
304     = MV_4 {-# UNPACK #-} !Int !(MVector s a)
305                                !(MVector s b)
306                                !(MVector s c)
307                                !(MVector s d)
308 data instance Vector (a, b, c, d)
309     = V_4 {-# UNPACK #-} !Int !(Vector a)
310                               !(Vector b)
311                               !(Vector c)
312                               !(Vector d)
313 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
314 instance (Unbox a,
315           Unbox b,
316           Unbox c,
317           Unbox d) => M.MVector MVector (a, b, c, d) where
318   {-# INLINE basicLength  #-}
319   basicLength (MV_4 n_ as bs cs ds) = n_
320   {-# INLINE basicUnsafeSlice  #-}
321   basicUnsafeSlice i_ m_ (MV_4 n_ as bs cs ds)
322       = MV_4 m_ (M.basicUnsafeSlice i_ m_ as)
323                 (M.basicUnsafeSlice i_ m_ bs)
324                 (M.basicUnsafeSlice i_ m_ cs)
325                 (M.basicUnsafeSlice i_ m_ ds)
326   {-# INLINE basicOverlaps  #-}
327   basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
328       = M.basicOverlaps as1 as2
329         || M.basicOverlaps bs1 bs2
330         || M.basicOverlaps cs1 cs2
331         || M.basicOverlaps ds1 ds2
332   {-# INLINE basicUnsafeNew  #-}
333   basicUnsafeNew n_
334       = do
335           as <- M.basicUnsafeNew n_
336           bs <- M.basicUnsafeNew n_
337           cs <- M.basicUnsafeNew n_
338           ds <- M.basicUnsafeNew n_
339           return $ MV_4 n_ as bs cs ds
340   {-# INLINE basicUnsafeReplicate  #-}
341   basicUnsafeReplicate n_ (a, b, c, d)
342       = do
343           as <- M.basicUnsafeReplicate n_ a
344           bs <- M.basicUnsafeReplicate n_ b
345           cs <- M.basicUnsafeReplicate n_ c
346           ds <- M.basicUnsafeReplicate n_ d
347           return $ MV_4 n_ as bs cs ds
348   {-# INLINE basicUnsafeRead  #-}
349   basicUnsafeRead (MV_4 n_ as bs cs ds) i_
350       = do
351           a <- M.basicUnsafeRead as i_
352           b <- M.basicUnsafeRead bs i_
353           c <- M.basicUnsafeRead cs i_
354           d <- M.basicUnsafeRead ds i_
355           return (a, b, c, d)
356   {-# INLINE basicUnsafeWrite  #-}
357   basicUnsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
358       = do
359           M.basicUnsafeWrite as i_ a
360           M.basicUnsafeWrite bs i_ b
361           M.basicUnsafeWrite cs i_ c
362           M.basicUnsafeWrite ds i_ d
363   {-# INLINE basicClear  #-}
364   basicClear (MV_4 n_ as bs cs ds)
365       = do
366           M.basicClear as
367           M.basicClear bs
368           M.basicClear cs
369           M.basicClear ds
370   {-# INLINE basicSet  #-}
371   basicSet (MV_4 n_ as bs cs ds) (a, b, c, d)
372       = do
373           M.basicSet as a
374           M.basicSet bs b
375           M.basicSet cs c
376           M.basicSet ds d
377   {-# INLINE basicUnsafeCopy  #-}
378   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
379                                                        bs2
380                                                        cs2
381                                                        ds2)
382       = do
383           M.basicUnsafeCopy as1 as2
384           M.basicUnsafeCopy bs1 bs2
385           M.basicUnsafeCopy cs1 cs2
386           M.basicUnsafeCopy ds1 ds2
387   {-# INLINE basicUnsafeMove  #-}
388   basicUnsafeMove (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
389                                                        bs2
390                                                        cs2
391                                                        ds2)
392       = do
393           M.basicUnsafeMove as1 as2
394           M.basicUnsafeMove bs1 bs2
395           M.basicUnsafeMove cs1 cs2
396           M.basicUnsafeMove ds1 ds2
397   {-# INLINE basicUnsafeGrow  #-}
398   basicUnsafeGrow (MV_4 n_ as bs cs ds) m_
399       = do
400           as' <- M.basicUnsafeGrow as m_
401           bs' <- M.basicUnsafeGrow bs m_
402           cs' <- M.basicUnsafeGrow cs m_
403           ds' <- M.basicUnsafeGrow ds m_
404           return $ MV_4 (m_+n_) as' bs' cs' ds'
405 instance (Unbox a,
406           Unbox b,
407           Unbox c,
408           Unbox d) => G.Vector Vector (a, b, c, d) where
409   {-# INLINE basicUnsafeFreeze  #-}
410   basicUnsafeFreeze (MV_4 n_ as bs cs ds)
411       = do
412           as' <- G.basicUnsafeFreeze as
413           bs' <- G.basicUnsafeFreeze bs
414           cs' <- G.basicUnsafeFreeze cs
415           ds' <- G.basicUnsafeFreeze ds
416           return $ V_4 n_ as' bs' cs' ds'
417   {-# INLINE basicUnsafeThaw  #-}
418   basicUnsafeThaw (V_4 n_ as bs cs ds)
419       = do
420           as' <- G.basicUnsafeThaw as
421           bs' <- G.basicUnsafeThaw bs
422           cs' <- G.basicUnsafeThaw cs
423           ds' <- G.basicUnsafeThaw ds
424           return $ MV_4 n_ as' bs' cs' ds'
425   {-# INLINE basicLength  #-}
426   basicLength (V_4 n_ as bs cs ds) = n_
427   {-# INLINE basicUnsafeSlice  #-}
428   basicUnsafeSlice i_ m_ (V_4 n_ as bs cs ds)
429       = V_4 m_ (G.basicUnsafeSlice i_ m_ as)
430                (G.basicUnsafeSlice i_ m_ bs)
431                (G.basicUnsafeSlice i_ m_ cs)
432                (G.basicUnsafeSlice i_ m_ ds)
433   {-# INLINE basicUnsafeIndexM  #-}
434   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
435       = do
436           a <- G.basicUnsafeIndexM as i_
437           b <- G.basicUnsafeIndexM bs i_
438           c <- G.basicUnsafeIndexM cs i_
439           d <- G.basicUnsafeIndexM ds i_
440           return (a, b, c, d)
441   {-# INLINE basicUnsafeCopy  #-}
442   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (V_4 n_2 as2
443                                                       bs2
444                                                       cs2
445                                                       ds2)
446       = do
447           G.basicUnsafeCopy as1 as2
448           G.basicUnsafeCopy bs1 bs2
449           G.basicUnsafeCopy cs1 cs2
450           G.basicUnsafeCopy ds1 ds2
451   {-# INLINE elemseq  #-}
452   elemseq _ (a, b, c, d)
453       = G.elemseq (undefined :: Vector a) a
454         . G.elemseq (undefined :: Vector b) b
455         . G.elemseq (undefined :: Vector c) c
456         . G.elemseq (undefined :: Vector d) d
457 #endif
458 #ifdef DEFINE_MUTABLE
459 -- | /O(1)/ Zip 4 vectors
460 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
461                                                 MVector s b ->
462                                                 MVector s c ->
463                                                 MVector s d -> MVector s (a, b, c, d)
464 {-# INLINE_FUSED zip4 #-}
465 zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as)
466                             (unsafeSlice 0 len bs)
467                             (unsafeSlice 0 len cs)
468                             (unsafeSlice 0 len ds)
469   where
470     len = length as `delayed_min`
471           length bs `delayed_min`
472           length cs `delayed_min`
473           length ds
474 -- | /O(1)/ Unzip 4 vectors
475 unzip4 :: (Unbox a,
476            Unbox b,
477            Unbox c,
478            Unbox d) => MVector s (a, b, c, d) -> (MVector s a,
479                                                   MVector s b,
480                                                   MVector s c,
481                                                   MVector s d)
482 {-# INLINE unzip4 #-}
483 unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
484 #endif
485 #ifdef DEFINE_IMMUTABLE
486 -- | /O(1)/ Zip 4 vectors
487 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
488                                                 Vector b ->
489                                                 Vector c ->
490                                                 Vector d -> Vector (a, b, c, d)
491 {-# INLINE_FUSED zip4 #-}
492 zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as)
493                            (unsafeSlice 0 len bs)
494                            (unsafeSlice 0 len cs)
495                            (unsafeSlice 0 len ds)
496   where
497     len = length as `delayed_min`
498           length bs `delayed_min`
499           length cs `delayed_min`
500           length ds
501 {-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds .
502   G.stream (zip4 as bs cs ds) = Bundle.zipWith4 (, , ,) (G.stream as)
503                                                         (G.stream bs)
504                                                         (G.stream cs)
505                                                         (G.stream ds)
506   #-}
507 -- | /O(1)/ Unzip 4 vectors
508 unzip4 :: (Unbox a,
509            Unbox b,
510            Unbox c,
511            Unbox d) => Vector (a, b, c, d) -> (Vector a,
512                                                Vector b,
513                                                Vector c,
514                                                Vector d)
515 {-# INLINE unzip4 #-}
516 unzip4 (V_4 n_ as bs cs ds) = (as, bs, cs, ds)
517 #endif
518 #ifdef DEFINE_INSTANCES
519 data instance MVector s (a, b, c, d, e)
520     = MV_5 {-# UNPACK #-} !Int !(MVector s a)
521                                !(MVector s b)
522                                !(MVector s c)
523                                !(MVector s d)
524                                !(MVector s e)
525 data instance Vector (a, b, c, d, e)
526     = V_5 {-# UNPACK #-} !Int !(Vector a)
527                               !(Vector b)
528                               !(Vector c)
529                               !(Vector d)
530                               !(Vector e)
531 instance (Unbox a,
532           Unbox b,
533           Unbox c,
534           Unbox d,
535           Unbox e) => Unbox (a, b, c, d, e)
536 instance (Unbox a,
537           Unbox b,
538           Unbox c,
539           Unbox d,
540           Unbox e) => M.MVector MVector (a, b, c, d, e) where
541   {-# INLINE basicLength  #-}
542   basicLength (MV_5 n_ as bs cs ds es) = n_
543   {-# INLINE basicUnsafeSlice  #-}
544   basicUnsafeSlice i_ m_ (MV_5 n_ as bs cs ds es)
545       = MV_5 m_ (M.basicUnsafeSlice i_ m_ as)
546                 (M.basicUnsafeSlice i_ m_ bs)
547                 (M.basicUnsafeSlice i_ m_ cs)
548                 (M.basicUnsafeSlice i_ m_ ds)
549                 (M.basicUnsafeSlice i_ m_ es)
550   {-# INLINE basicOverlaps  #-}
551   basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
552                                                          bs2
553                                                          cs2
554                                                          ds2
555                                                          es2)
556       = M.basicOverlaps as1 as2
557         || M.basicOverlaps bs1 bs2
558         || M.basicOverlaps cs1 cs2
559         || M.basicOverlaps ds1 ds2
560         || M.basicOverlaps es1 es2
561   {-# INLINE basicUnsafeNew  #-}
562   basicUnsafeNew n_
563       = do
564           as <- M.basicUnsafeNew n_
565           bs <- M.basicUnsafeNew n_
566           cs <- M.basicUnsafeNew n_
567           ds <- M.basicUnsafeNew n_
568           es <- M.basicUnsafeNew n_
569           return $ MV_5 n_ as bs cs ds es
570   {-# INLINE basicUnsafeReplicate  #-}
571   basicUnsafeReplicate n_ (a, b, c, d, e)
572       = do
573           as <- M.basicUnsafeReplicate n_ a
574           bs <- M.basicUnsafeReplicate n_ b
575           cs <- M.basicUnsafeReplicate n_ c
576           ds <- M.basicUnsafeReplicate n_ d
577           es <- M.basicUnsafeReplicate n_ e
578           return $ MV_5 n_ as bs cs ds es
579   {-# INLINE basicUnsafeRead  #-}
580   basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
581       = do
582           a <- M.basicUnsafeRead as i_
583           b <- M.basicUnsafeRead bs i_
584           c <- M.basicUnsafeRead cs i_
585           d <- M.basicUnsafeRead ds i_
586           e <- M.basicUnsafeRead es i_
587           return (a, b, c, d, e)
588   {-# INLINE basicUnsafeWrite  #-}
589   basicUnsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
590       = do
591           M.basicUnsafeWrite as i_ a
592           M.basicUnsafeWrite bs i_ b
593           M.basicUnsafeWrite cs i_ c
594           M.basicUnsafeWrite ds i_ d
595           M.basicUnsafeWrite es i_ e
596   {-# INLINE basicClear  #-}
597   basicClear (MV_5 n_ as bs cs ds es)
598       = do
599           M.basicClear as
600           M.basicClear bs
601           M.basicClear cs
602           M.basicClear ds
603           M.basicClear es
604   {-# INLINE basicSet  #-}
605   basicSet (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
606       = do
607           M.basicSet as a
608           M.basicSet bs b
609           M.basicSet cs c
610           M.basicSet ds d
611           M.basicSet es e
612   {-# INLINE basicUnsafeCopy  #-}
613   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
614                                                            bs2
615                                                            cs2
616                                                            ds2
617                                                            es2)
618       = do
619           M.basicUnsafeCopy as1 as2
620           M.basicUnsafeCopy bs1 bs2
621           M.basicUnsafeCopy cs1 cs2
622           M.basicUnsafeCopy ds1 ds2
623           M.basicUnsafeCopy es1 es2
624   {-# INLINE basicUnsafeMove  #-}
625   basicUnsafeMove (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
626                                                            bs2
627                                                            cs2
628                                                            ds2
629                                                            es2)
630       = do
631           M.basicUnsafeMove as1 as2
632           M.basicUnsafeMove bs1 bs2
633           M.basicUnsafeMove cs1 cs2
634           M.basicUnsafeMove ds1 ds2
635           M.basicUnsafeMove es1 es2
636   {-# INLINE basicUnsafeGrow  #-}
637   basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
638       = do
639           as' <- M.basicUnsafeGrow as m_
640           bs' <- M.basicUnsafeGrow bs m_
641           cs' <- M.basicUnsafeGrow cs m_
642           ds' <- M.basicUnsafeGrow ds m_
643           es' <- M.basicUnsafeGrow es m_
644           return $ MV_5 (m_+n_) as' bs' cs' ds' es'
645 instance (Unbox a,
646           Unbox b,
647           Unbox c,
648           Unbox d,
649           Unbox e) => G.Vector Vector (a, b, c, d, e) where
650   {-# INLINE basicUnsafeFreeze  #-}
651   basicUnsafeFreeze (MV_5 n_ as bs cs ds es)
652       = do
653           as' <- G.basicUnsafeFreeze as
654           bs' <- G.basicUnsafeFreeze bs
655           cs' <- G.basicUnsafeFreeze cs
656           ds' <- G.basicUnsafeFreeze ds
657           es' <- G.basicUnsafeFreeze es
658           return $ V_5 n_ as' bs' cs' ds' es'
659   {-# INLINE basicUnsafeThaw  #-}
660   basicUnsafeThaw (V_5 n_ as bs cs ds es)
661       = do
662           as' <- G.basicUnsafeThaw as
663           bs' <- G.basicUnsafeThaw bs
664           cs' <- G.basicUnsafeThaw cs
665           ds' <- G.basicUnsafeThaw ds
666           es' <- G.basicUnsafeThaw es
667           return $ MV_5 n_ as' bs' cs' ds' es'
668   {-# INLINE basicLength  #-}
669   basicLength (V_5 n_ as bs cs ds es) = n_
670   {-# INLINE basicUnsafeSlice  #-}
671   basicUnsafeSlice i_ m_ (V_5 n_ as bs cs ds es)
672       = V_5 m_ (G.basicUnsafeSlice i_ m_ as)
673                (G.basicUnsafeSlice i_ m_ bs)
674                (G.basicUnsafeSlice i_ m_ cs)
675                (G.basicUnsafeSlice i_ m_ ds)
676                (G.basicUnsafeSlice i_ m_ es)
677   {-# INLINE basicUnsafeIndexM  #-}
678   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
679       = do
680           a <- G.basicUnsafeIndexM as i_
681           b <- G.basicUnsafeIndexM bs i_
682           c <- G.basicUnsafeIndexM cs i_
683           d <- G.basicUnsafeIndexM ds i_
684           e <- G.basicUnsafeIndexM es i_
685           return (a, b, c, d, e)
686   {-# INLINE basicUnsafeCopy  #-}
687   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (V_5 n_2 as2
688                                                           bs2
689                                                           cs2
690                                                           ds2
691                                                           es2)
692       = do
693           G.basicUnsafeCopy as1 as2
694           G.basicUnsafeCopy bs1 bs2
695           G.basicUnsafeCopy cs1 cs2
696           G.basicUnsafeCopy ds1 ds2
697           G.basicUnsafeCopy es1 es2
698   {-# INLINE elemseq  #-}
699   elemseq _ (a, b, c, d, e)
700       = G.elemseq (undefined :: Vector a) a
701         . G.elemseq (undefined :: Vector b) b
702         . G.elemseq (undefined :: Vector c) c
703         . G.elemseq (undefined :: Vector d) d
704         . G.elemseq (undefined :: Vector e) e
705 #endif
706 #ifdef DEFINE_MUTABLE
707 -- | /O(1)/ Zip 5 vectors
708 zip5 :: (Unbox a,
709          Unbox b,
710          Unbox c,
711          Unbox d,
712          Unbox e) => MVector s a ->
713                      MVector s b ->
714                      MVector s c ->
715                      MVector s d ->
716                      MVector s e -> MVector s (a, b, c, d, e)
717 {-# INLINE_FUSED zip5 #-}
718 zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as)
719                                (unsafeSlice 0 len bs)
720                                (unsafeSlice 0 len cs)
721                                (unsafeSlice 0 len ds)
722                                (unsafeSlice 0 len es)
723   where
724     len = length as `delayed_min`
725           length bs `delayed_min`
726           length cs `delayed_min`
727           length ds `delayed_min`
728           length es
729 -- | /O(1)/ Unzip 5 vectors
730 unzip5 :: (Unbox a,
731            Unbox b,
732            Unbox c,
733            Unbox d,
734            Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
735                                                      MVector s b,
736                                                      MVector s c,
737                                                      MVector s d,
738                                                      MVector s e)
739 {-# INLINE unzip5 #-}
740 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
741 #endif
742 #ifdef DEFINE_IMMUTABLE
743 -- | /O(1)/ Zip 5 vectors
744 zip5 :: (Unbox a,
745          Unbox b,
746          Unbox c,
747          Unbox d,
748          Unbox e) => Vector a ->
749                      Vector b ->
750                      Vector c ->
751                      Vector d ->
752                      Vector e -> Vector (a, b, c, d, e)
753 {-# INLINE_FUSED zip5 #-}
754 zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
755                               (unsafeSlice 0 len bs)
756                               (unsafeSlice 0 len cs)
757                               (unsafeSlice 0 len ds)
758                               (unsafeSlice 0 len es)
759   where
760     len = length as `delayed_min`
761           length bs `delayed_min`
762           length cs `delayed_min`
763           length ds `delayed_min`
764           length es
765 {-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
766   G.stream (zip5 as
767                  bs
768                  cs
769                  ds
770                  es) = Bundle.zipWith5 (, , , ,) (G.stream as)
771                                                  (G.stream bs)
772                                                  (G.stream cs)
773                                                  (G.stream ds)
774                                                  (G.stream es)
775   #-}
776 -- | /O(1)/ Unzip 5 vectors
777 unzip5 :: (Unbox a,
778            Unbox b,
779            Unbox c,
780            Unbox d,
781            Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
782                                                   Vector b,
783                                                   Vector c,
784                                                   Vector d,
785                                                   Vector e)
786 {-# INLINE unzip5 #-}
787 unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
788 #endif
789 #ifdef DEFINE_INSTANCES
790 data instance MVector s (a, b, c, d, e, f)
791     = MV_6 {-# UNPACK #-} !Int !(MVector s a)
792                                !(MVector s b)
793                                !(MVector s c)
794                                !(MVector s d)
795                                !(MVector s e)
796                                !(MVector s f)
797 data instance Vector (a, b, c, d, e, f)
798     = V_6 {-# UNPACK #-} !Int !(Vector a)
799                               !(Vector b)
800                               !(Vector c)
801                               !(Vector d)
802                               !(Vector e)
803                               !(Vector f)
804 instance (Unbox a,
805           Unbox b,
806           Unbox c,
807           Unbox d,
808           Unbox e,
809           Unbox f) => Unbox (a, b, c, d, e, f)
810 instance (Unbox a,
811           Unbox b,
812           Unbox c,
813           Unbox d,
814           Unbox e,
815           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
816   {-# INLINE basicLength  #-}
817   basicLength (MV_6 n_ as bs cs ds es fs) = n_
818   {-# INLINE basicUnsafeSlice  #-}
819   basicUnsafeSlice i_ m_ (MV_6 n_ as bs cs ds es fs)
820       = MV_6 m_ (M.basicUnsafeSlice i_ m_ as)
821                 (M.basicUnsafeSlice i_ m_ bs)
822                 (M.basicUnsafeSlice i_ m_ cs)
823                 (M.basicUnsafeSlice i_ m_ ds)
824                 (M.basicUnsafeSlice i_ m_ es)
825                 (M.basicUnsafeSlice i_ m_ fs)
826   {-# INLINE basicOverlaps  #-}
827   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
828                                                              bs2
829                                                              cs2
830                                                              ds2
831                                                              es2
832                                                              fs2)
833       = M.basicOverlaps as1 as2
834         || M.basicOverlaps bs1 bs2
835         || M.basicOverlaps cs1 cs2
836         || M.basicOverlaps ds1 ds2
837         || M.basicOverlaps es1 es2
838         || M.basicOverlaps fs1 fs2
839   {-# INLINE basicUnsafeNew  #-}
840   basicUnsafeNew n_
841       = do
842           as <- M.basicUnsafeNew n_
843           bs <- M.basicUnsafeNew n_
844           cs <- M.basicUnsafeNew n_
845           ds <- M.basicUnsafeNew n_
846           es <- M.basicUnsafeNew n_
847           fs <- M.basicUnsafeNew n_
848           return $ MV_6 n_ as bs cs ds es fs
849   {-# INLINE basicUnsafeReplicate  #-}
850   basicUnsafeReplicate n_ (a, b, c, d, e, f)
851       = do
852           as <- M.basicUnsafeReplicate n_ a
853           bs <- M.basicUnsafeReplicate n_ b
854           cs <- M.basicUnsafeReplicate n_ c
855           ds <- M.basicUnsafeReplicate n_ d
856           es <- M.basicUnsafeReplicate n_ e
857           fs <- M.basicUnsafeReplicate n_ f
858           return $ MV_6 n_ as bs cs ds es fs
859   {-# INLINE basicUnsafeRead  #-}
860   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
861       = do
862           a <- M.basicUnsafeRead as i_
863           b <- M.basicUnsafeRead bs i_
864           c <- M.basicUnsafeRead cs i_
865           d <- M.basicUnsafeRead ds i_
866           e <- M.basicUnsafeRead es i_
867           f <- M.basicUnsafeRead fs i_
868           return (a, b, c, d, e, f)
869   {-# INLINE basicUnsafeWrite  #-}
870   basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
871       = do
872           M.basicUnsafeWrite as i_ a
873           M.basicUnsafeWrite bs i_ b
874           M.basicUnsafeWrite cs i_ c
875           M.basicUnsafeWrite ds i_ d
876           M.basicUnsafeWrite es i_ e
877           M.basicUnsafeWrite fs i_ f
878   {-# INLINE basicClear  #-}
879   basicClear (MV_6 n_ as bs cs ds es fs)
880       = do
881           M.basicClear as
882           M.basicClear bs
883           M.basicClear cs
884           M.basicClear ds
885           M.basicClear es
886           M.basicClear fs
887   {-# INLINE basicSet  #-}
888   basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
889       = do
890           M.basicSet as a
891           M.basicSet bs b
892           M.basicSet cs c
893           M.basicSet ds d
894           M.basicSet es e
895           M.basicSet fs f
896   {-# INLINE basicUnsafeCopy  #-}
897   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
898                                                                bs2
899                                                                cs2
900                                                                ds2
901                                                                es2
902                                                                fs2)
903       = do
904           M.basicUnsafeCopy as1 as2
905           M.basicUnsafeCopy bs1 bs2
906           M.basicUnsafeCopy cs1 cs2
907           M.basicUnsafeCopy ds1 ds2
908           M.basicUnsafeCopy es1 es2
909           M.basicUnsafeCopy fs1 fs2
910   {-# INLINE basicUnsafeMove  #-}
911   basicUnsafeMove (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
912                                                                bs2
913                                                                cs2
914                                                                ds2
915                                                                es2
916                                                                fs2)
917       = do
918           M.basicUnsafeMove as1 as2
919           M.basicUnsafeMove bs1 bs2
920           M.basicUnsafeMove cs1 cs2
921           M.basicUnsafeMove ds1 ds2
922           M.basicUnsafeMove es1 es2
923           M.basicUnsafeMove fs1 fs2
924   {-# INLINE basicUnsafeGrow  #-}
925   basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
926       = do
927           as' <- M.basicUnsafeGrow as m_
928           bs' <- M.basicUnsafeGrow bs m_
929           cs' <- M.basicUnsafeGrow cs m_
930           ds' <- M.basicUnsafeGrow ds m_
931           es' <- M.basicUnsafeGrow es m_
932           fs' <- M.basicUnsafeGrow fs m_
933           return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs'
934 instance (Unbox a,
935           Unbox b,
936           Unbox c,
937           Unbox d,
938           Unbox e,
939           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
940   {-# INLINE basicUnsafeFreeze  #-}
941   basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs)
942       = do
943           as' <- G.basicUnsafeFreeze as
944           bs' <- G.basicUnsafeFreeze bs
945           cs' <- G.basicUnsafeFreeze cs
946           ds' <- G.basicUnsafeFreeze ds
947           es' <- G.basicUnsafeFreeze es
948           fs' <- G.basicUnsafeFreeze fs
949           return $ V_6 n_ as' bs' cs' ds' es' fs'
950   {-# INLINE basicUnsafeThaw  #-}
951   basicUnsafeThaw (V_6 n_ as bs cs ds es fs)
952       = do
953           as' <- G.basicUnsafeThaw as
954           bs' <- G.basicUnsafeThaw bs
955           cs' <- G.basicUnsafeThaw cs
956           ds' <- G.basicUnsafeThaw ds
957           es' <- G.basicUnsafeThaw es
958           fs' <- G.basicUnsafeThaw fs
959           return $ MV_6 n_ as' bs' cs' ds' es' fs'
960   {-# INLINE basicLength  #-}
961   basicLength (V_6 n_ as bs cs ds es fs) = n_
962   {-# INLINE basicUnsafeSlice  #-}
963   basicUnsafeSlice i_ m_ (V_6 n_ as bs cs ds es fs)
964       = V_6 m_ (G.basicUnsafeSlice i_ m_ as)
965                (G.basicUnsafeSlice i_ m_ bs)
966                (G.basicUnsafeSlice i_ m_ cs)
967                (G.basicUnsafeSlice i_ m_ ds)
968                (G.basicUnsafeSlice i_ m_ es)
969                (G.basicUnsafeSlice i_ m_ fs)
970   {-# INLINE basicUnsafeIndexM  #-}
971   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
972       = do
973           a <- G.basicUnsafeIndexM as i_
974           b <- G.basicUnsafeIndexM bs i_
975           c <- G.basicUnsafeIndexM cs i_
976           d <- G.basicUnsafeIndexM ds i_
977           e <- G.basicUnsafeIndexM es i_
978           f <- G.basicUnsafeIndexM fs i_
979           return (a, b, c, d, e, f)
980   {-# INLINE basicUnsafeCopy  #-}
981   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (V_6 n_2 as2
982                                                               bs2
983                                                               cs2
984                                                               ds2
985                                                               es2
986                                                               fs2)
987       = do
988           G.basicUnsafeCopy as1 as2
989           G.basicUnsafeCopy bs1 bs2
990           G.basicUnsafeCopy cs1 cs2
991           G.basicUnsafeCopy ds1 ds2
992           G.basicUnsafeCopy es1 es2
993           G.basicUnsafeCopy fs1 fs2
994   {-# INLINE elemseq  #-}
995   elemseq _ (a, b, c, d, e, f)
996       = G.elemseq (undefined :: Vector a) a
997         . G.elemseq (undefined :: Vector b) b
998         . G.elemseq (undefined :: Vector c) c
999         . G.elemseq (undefined :: Vector d) d
1000         . G.elemseq (undefined :: Vector e) e
1001         . G.elemseq (undefined :: Vector f) f
1002 #endif
1003 #ifdef DEFINE_MUTABLE
1004 -- | /O(1)/ Zip 6 vectors
1005 zip6 :: (Unbox a,
1006          Unbox b,
1007          Unbox c,
1008          Unbox d,
1009          Unbox e,
1010          Unbox f) => MVector s a ->
1011                      MVector s b ->
1012                      MVector s c ->
1013                      MVector s d ->
1014                      MVector s e ->
1015                      MVector s f -> MVector s (a, b, c, d, e, f)
1016 {-# INLINE_FUSED zip6 #-}
1017 zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
1018                                   (unsafeSlice 0 len bs)
1019                                   (unsafeSlice 0 len cs)
1020                                   (unsafeSlice 0 len ds)
1021                                   (unsafeSlice 0 len es)
1022                                   (unsafeSlice 0 len fs)
1023   where
1024     len = length as `delayed_min`
1025           length bs `delayed_min`
1026           length cs `delayed_min`
1027           length ds `delayed_min`
1028           length es `delayed_min`
1029           length fs
1030 -- | /O(1)/ Unzip 6 vectors
1031 unzip6 :: (Unbox a,
1032            Unbox b,
1033            Unbox c,
1034            Unbox d,
1035            Unbox e,
1036            Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
1037                                                         MVector s b,
1038                                                         MVector s c,
1039                                                         MVector s d,
1040                                                         MVector s e,
1041                                                         MVector s f)
1042 {-# INLINE unzip6 #-}
1043 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
1044 #endif
1045 #ifdef DEFINE_IMMUTABLE
1046 -- | /O(1)/ Zip 6 vectors
1047 zip6 :: (Unbox a,
1048          Unbox b,
1049          Unbox c,
1050          Unbox d,
1051          Unbox e,
1052          Unbox f) => Vector a ->
1053                      Vector b ->
1054                      Vector c ->
1055                      Vector d ->
1056                      Vector e ->
1057                      Vector f -> Vector (a, b, c, d, e, f)
1058 {-# INLINE_FUSED zip6 #-}
1059 zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
1060                                  (unsafeSlice 0 len bs)
1061                                  (unsafeSlice 0 len cs)
1062                                  (unsafeSlice 0 len ds)
1063                                  (unsafeSlice 0 len es)
1064                                  (unsafeSlice 0 len fs)
1065   where
1066     len = length as `delayed_min`
1067           length bs `delayed_min`
1068           length cs `delayed_min`
1069           length ds `delayed_min`
1070           length es `delayed_min`
1071           length fs
1072 {-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
1073   G.stream (zip6 as
1074                  bs
1075                  cs
1076                  ds
1077                  es
1078                  fs) = Bundle.zipWith6 (, , , , ,) (G.stream as)
1079                                                    (G.stream bs)
1080                                                    (G.stream cs)
1081                                                    (G.stream ds)
1082                                                    (G.stream es)
1083                                                    (G.stream fs)
1084   #-}
1085 -- | /O(1)/ Unzip 6 vectors
1086 unzip6 :: (Unbox a,
1087            Unbox b,
1088            Unbox c,
1089            Unbox d,
1090            Unbox e,
1091            Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
1092                                                      Vector b,
1093                                                      Vector c,
1094                                                      Vector d,
1095                                                      Vector e,
1096                                                      Vector f)
1097 {-# INLINE unzip6 #-}
1098 unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
1099 #endif