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