{-# language BangPatterns #-}
{-# language DerivingStrategies #-}
{-# language TypeFamilies #-}
{-# language MagicHash #-}
{-# language UnboxedTuples #-}
module Data.Chunks
( Chunks(..)
, null
, reverse
, reverseOnto
, copy
, copyReverse
, concat
, concatReverse
, index
, map'
, singleton
, doubleton
, tripleton
, quadrupleton
, quintupleton
, sextupleton
, septupleton
, octupleton
, nonupleton
, decupleton
, undecupleton
, duodecupleton
, construct1
, construct2
, construct3
, construct4
, construct5
, construct6
, construct7
, construct8
, construct9
, construct10
, construct11
, construct12
) where
import Prelude hiding (reverse,concat,null)
import Data.Primitive (SmallArray(..),SmallMutableArray(..))
import GHC.Exts (IsList,Int#,State#,SmallMutableArray#,Int(I#),(+#),(-#))
import GHC.Exts (SmallArray#)
import GHC.ST (ST(..))
import Control.Monad.ST.Run (runSmallArrayST)
import qualified GHC.Exts as Exts
import qualified Data.Foldable as F
import qualified Data.Primitive as PM
data Chunks a
= ChunksCons !(SmallArray a) !(Chunks a)
| ChunksNil
deriving stock (Int -> Chunks a -> ShowS
forall a. Show a => Int -> Chunks a -> ShowS
forall a. Show a => [Chunks a] -> ShowS
forall a. Show a => Chunks a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Chunks a] -> ShowS
$cshowList :: forall a. Show a => [Chunks a] -> ShowS
show :: Chunks a -> String
$cshow :: forall a. Show a => Chunks a -> String
showsPrec :: Int -> Chunks a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Chunks a -> ShowS
Show)
instance Eq a => Eq (Chunks a) where
== :: Chunks a -> Chunks a -> Bool
(==) = forall a. Eq a => Chunks a -> Chunks a -> Bool
eqChunks
instance IsList (Chunks a) where
type Item (Chunks a) = SmallArray a
toList :: Chunks a -> [Item (Chunks a)]
toList = forall a. Chunks a -> [SmallArray a]
chunksToSmallArrayList
fromList :: [Item (Chunks a)] -> Chunks a
fromList [Item (Chunks a)]
xs = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
F.foldr forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons forall a. Chunks a
ChunksNil [Item (Chunks a)]
xs
null :: Chunks a -> Bool
null :: forall a. Chunks a -> Bool
null = forall a. Chunks a -> Bool
go where
go :: Chunks a -> Bool
go Chunks a
ChunksNil = Bool
True
go (ChunksCons SmallArray a
x Chunks a
xs) = case forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
x of
Int
0 -> Chunks a -> Bool
go Chunks a
xs
Int
_ -> Bool
False
index :: Chunks a -> Int -> Maybe a
index :: forall a. Chunks a -> Int -> Maybe a
index Chunks a
cs0 !Int
ix0 = forall a. Chunks a -> Int -> Maybe a
go Chunks a
cs0 Int
ix0 where
go :: Chunks a -> Int -> Maybe a
go Chunks a
ChunksNil !Int
_ = forall a. Maybe a
Nothing
go (ChunksCons SmallArray a
x Chunks a
xs) !Int
ix =
let !len :: Int
len = forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
x in
if Int
ix forall a. Ord a => a -> a -> Bool
< Int
len
then case forall a. SmallArray a -> Int -> (# a #)
PM.indexSmallArray## SmallArray a
x Int
ix of
(# a
v #) -> forall a. a -> Maybe a
Just a
v
else Chunks a -> Int -> Maybe a
go Chunks a
xs (Int
ix forall a. Num a => a -> a -> a
- Int
len)
chunksToSmallArrayList :: Chunks a -> [SmallArray a]
chunksToSmallArrayList :: forall a. Chunks a -> [SmallArray a]
chunksToSmallArrayList Chunks a
ChunksNil = []
chunksToSmallArrayList (ChunksCons SmallArray a
x Chunks a
xs) =
SmallArray a
x forall a. a -> [a] -> [a]
: forall a. Chunks a -> [SmallArray a]
chunksToSmallArrayList Chunks a
xs
eqChunks :: Eq a => Chunks a -> Chunks a -> Bool
eqChunks :: forall a. Eq a => Chunks a -> Chunks a -> Bool
eqChunks Chunks a
ChunksNil Chunks a
cs = forall a. Chunks a -> Bool
allEmpty Chunks a
cs
eqChunks (ChunksCons SmallArray a
x Chunks a
xs) Chunks a
cs = forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons SmallArray a
x Int
0 (forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
x) Chunks a
xs Chunks a
cs
eqChunksCons :: Eq a => SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons :: forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons !SmallArray a
_ !Int
_ !Int
len Chunks a
xs Chunks a
ChunksNil = case Int
len of
Int
0 -> forall a. Chunks a -> Bool
allEmpty Chunks a
xs
Int
_ -> Bool
False
eqChunksCons SmallArray a
x !Int
off !Int
len Chunks a
xs (ChunksCons SmallArray a
y Chunks a
ys) =
forall a.
Eq a =>
SmallArray a
-> Int
-> Int
-> SmallArray a
-> Int
-> Int
-> Chunks a
-> Chunks a
-> Bool
eqChunksConsBoth SmallArray a
x Int
off Int
len SmallArray a
y Int
0 (forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
y) Chunks a
xs Chunks a
ys
eqChunksConsBoth :: Eq a => SmallArray a -> Int -> Int -> SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksConsBoth :: forall a.
Eq a =>
SmallArray a
-> Int
-> Int
-> SmallArray a
-> Int
-> Int
-> Chunks a
-> Chunks a
-> Bool
eqChunksConsBoth !SmallArray a
xh !Int
xoff !Int
xlen !SmallArray a
yh !Int
yoff !Int
ylen !Chunks a
xt !Chunks a
yt = case forall a. Ord a => a -> a -> Ordering
compare Int
xlen Int
ylen of
Ordering
LT -> forall a.
Eq a =>
SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange SmallArray a
xh Int
xoff SmallArray a
yh Int
yoff Int
xlen Bool -> Bool -> Bool
&& forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons SmallArray a
yh (Int
yoff forall a. Num a => a -> a -> a
+ Int
xlen) (Int
ylen forall a. Num a => a -> a -> a
- Int
xlen) Chunks a
yt Chunks a
xt
Ordering
GT -> forall a.
Eq a =>
SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange SmallArray a
xh Int
xoff SmallArray a
yh Int
yoff Int
ylen Bool -> Bool -> Bool
&& forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons SmallArray a
xh (Int
xoff forall a. Num a => a -> a -> a
+ Int
ylen) (Int
xlen forall a. Num a => a -> a -> a
- Int
ylen) Chunks a
xt Chunks a
yt
Ordering
EQ -> forall a.
Eq a =>
SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange SmallArray a
xh Int
xoff SmallArray a
yh Int
yoff Int
xlen Bool -> Bool -> Bool
&& forall a. Eq a => Chunks a -> Chunks a -> Bool
eqChunks Chunks a
xt Chunks a
yt
eqRange :: Eq a => SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange :: forall a.
Eq a =>
SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange !SmallArray a
xs !Int
xoff !SmallArray a
ys !Int
yoff !Int
len
| Int
len forall a. Eq a => a -> a -> Bool
== Int
0 = Bool
True
| Bool
otherwise =
forall a. SmallArray a -> Int -> a
PM.indexSmallArray SmallArray a
xs Int
xoff forall a. Eq a => a -> a -> Bool
== forall a. SmallArray a -> Int -> a
PM.indexSmallArray SmallArray a
ys Int
yoff Bool -> Bool -> Bool
&&
forall a.
Eq a =>
SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange SmallArray a
xs (Int
xoff forall a. Num a => a -> a -> a
+ Int
1) SmallArray a
ys (Int
yoff forall a. Num a => a -> a -> a
+ Int
1) (Int
len forall a. Num a => a -> a -> a
- Int
1)
allEmpty :: Chunks a -> Bool
allEmpty :: forall a. Chunks a -> Bool
allEmpty Chunks a
ChunksNil = Bool
True
allEmpty (ChunksCons SmallArray a
x Chunks a
xs) = case forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
x of
Int
0 -> forall a. Chunks a -> Bool
allEmpty Chunks a
xs
Int
_ -> Bool
False
instance Semigroup (Chunks a) where
Chunks a
ChunksNil <> :: Chunks a -> Chunks a -> Chunks a
<> Chunks a
a = Chunks a
a
cs :: Chunks a
cs@(ChunksCons SmallArray a
_ Chunks a
_) <> Chunks a
ChunksNil = Chunks a
cs
as :: Chunks a
as@(ChunksCons SmallArray a
_ Chunks a
_) <> bs :: Chunks a
bs@(ChunksCons SmallArray a
_ Chunks a
_) =
forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto Chunks a
bs (forall a. Chunks a -> Chunks a
reverse Chunks a
as)
instance Monoid (Chunks a) where
mempty :: Chunks a
mempty = forall a. Chunks a
ChunksNil
instance Foldable Chunks where
{-# inline foldl' #-}
{-# inline foldr #-}
{-# inline length #-}
foldl' :: forall b a. (b -> a -> b) -> b -> Chunks a -> b
foldl' = forall b a. (b -> a -> b) -> b -> Chunks a -> b
chunksFoldl'
foldr :: forall a b. (a -> b -> b) -> b -> Chunks a -> b
foldr = forall a b. (a -> b -> b) -> b -> Chunks a -> b
chunksFoldr
length :: forall a. Chunks a -> Int
length = forall a. Chunks a -> Int
chunksLength
chunksFoldl' :: (b -> a -> b) -> b -> Chunks a -> b
{-# inline chunksFoldl' #-}
chunksFoldl' :: forall b a. (b -> a -> b) -> b -> Chunks a -> b
chunksFoldl' b -> a -> b
f = b -> Chunks a -> b
go where
go :: b -> Chunks a -> b
go !b
acc Chunks a
ChunksNil = b
acc
go !b
acc (ChunksCons SmallArray a
x Chunks a
cs) = b -> Chunks a -> b
go (forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' b -> a -> b
f b
acc SmallArray a
x) Chunks a
cs
chunksFoldr :: (a -> b -> b) -> b -> Chunks a -> b
{-# inline chunksFoldr #-}
chunksFoldr :: forall a b. (a -> b -> b) -> b -> Chunks a -> b
chunksFoldr a -> b -> b
f b
z0 = Chunks a -> b
go where
go :: Chunks a -> b
go Chunks a
ChunksNil = b
z0
go (ChunksCons SmallArray a
x Chunks a
cs) = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
F.foldr a -> b -> b
f (Chunks a -> b
go Chunks a
cs) SmallArray a
x
chunksLength :: Chunks a -> Int
{-# inline chunksLength #-}
chunksLength :: forall a. Chunks a -> Int
chunksLength = forall a. Int -> Chunks a -> Int
chunksLengthGo Int
0
chunksLengthGo :: Int -> Chunks a -> Int
chunksLengthGo :: forall a. Int -> Chunks a -> Int
chunksLengthGo !Int
n Chunks a
ChunksNil = Int
n
chunksLengthGo !Int
n (ChunksCons SmallArray a
c Chunks a
cs) =
forall a. Int -> Chunks a -> Int
chunksLengthGo (Int
n forall a. Num a => a -> a -> a
+ forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
c) Chunks a
cs
reverse :: Chunks a -> Chunks a
reverse :: forall a. Chunks a -> Chunks a
reverse = forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto forall a. Chunks a
ChunksNil
reverseOnto :: Chunks a -> Chunks a -> Chunks a
reverseOnto :: forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto !Chunks a
x Chunks a
ChunksNil = Chunks a
x
reverseOnto !Chunks a
x (ChunksCons SmallArray a
y Chunks a
ys) =
forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto (forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons SmallArray a
y Chunks a
x) Chunks a
ys
copy ::
SmallMutableArray s a
-> Int
-> Chunks a
-> ST s Int
{-# inline copy #-}
copy :: forall s a. SmallMutableArray s a -> Int -> Chunks a -> ST s Int
copy (SmallMutableArray SmallMutableArray# s a
dst) (I# Int#
off) Chunks a
cs = forall s a. STRep s a -> ST s a
ST
(\State# s
s0 -> case forall s a.
SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copy# SmallMutableArray# s a
dst Int#
off Chunks a
cs State# s
s0 of
(# State# s
s1, Int#
nextOff #) -> (# State# s
s1, Int# -> Int
I# Int#
nextOff #)
)
copy# :: SmallMutableArray# s a -> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copy# :: forall s a.
SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copy# SmallMutableArray# s a
_ Int#
off Chunks a
ChunksNil State# s
s0 = (# State# s
s0, Int#
off #)
copy# SmallMutableArray# s a
marr Int#
off (ChunksCons (SmallArray SmallArray# a
c) Chunks a
cs) State# s
s0 =
let !sz :: Int#
sz = forall a. SmallArray# a -> Int#
Exts.sizeofSmallArray# SmallArray# a
c in
case forall a d.
SmallArray# a
-> Int#
-> SmallMutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
Exts.copySmallArray# SmallArray# a
c Int#
0# SmallMutableArray# s a
marr Int#
off Int#
sz State# s
s0 of
State# s
s1 -> forall s a.
SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copy# SmallMutableArray# s a
marr (Int#
off Int# -> Int# -> Int#
+# Int#
sz) Chunks a
cs State# s
s1
copyReverse ::
SmallMutableArray s a
-> Int
-> Chunks a
-> ST s Int
{-# inline copyReverse #-}
copyReverse :: forall s a. SmallMutableArray s a -> Int -> Chunks a -> ST s Int
copyReverse (SmallMutableArray SmallMutableArray# s a
dst) (I# Int#
off) Chunks a
cs = forall s a. STRep s a -> ST s a
ST
(\State# s
s0 -> case forall s a.
SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copyReverse# SmallMutableArray# s a
dst Int#
off Chunks a
cs State# s
s0 of
(# State# s
s1, Int#
nextOff #) -> (# State# s
s1, Int# -> Int
I# Int#
nextOff #)
)
copyReverse# :: SmallMutableArray# s a -> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copyReverse# :: forall s a.
SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copyReverse# SmallMutableArray# s a
_ Int#
off Chunks a
ChunksNil State# s
s0 = (# State# s
s0, Int#
off #)
copyReverse# SmallMutableArray# s a
marr Int#
prevOff (ChunksCons (SmallArray SmallArray# a
c) Chunks a
cs) State# s
s0 =
let !sz :: Int#
sz = forall a. SmallArray# a -> Int#
Exts.sizeofSmallArray# SmallArray# a
c
!off :: Int#
off = Int#
prevOff Int# -> Int# -> Int#
-# Int#
sz in
case forall a d.
SmallArray# a
-> Int#
-> SmallMutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
Exts.copySmallArray# SmallArray# a
c Int#
0# SmallMutableArray# s a
marr Int#
off Int#
sz State# s
s0 of
State# s
s1 -> forall s a.
SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
copyReverse# SmallMutableArray# s a
marr Int#
off Chunks a
cs State# s
s1
concat :: Chunks a -> SmallArray a
{-# inline concat #-}
concat :: forall a. Chunks a -> SmallArray a
concat Chunks a
x = forall a. SmallArray# a -> SmallArray a
SmallArray (forall a. Chunks a -> SmallArray# a
concat# Chunks a
x)
concat# :: Chunks a -> SmallArray# a
{-# noinline concat# #-}
concat# :: forall a. Chunks a -> SmallArray# a
concat# Chunks a
ChunksNil = case forall a. Monoid a => a
mempty of {SmallArray SmallArray# a
x -> SmallArray# a
x}
concat# (ChunksCons SmallArray a
c Chunks a
cs) = case Chunks a
cs of
Chunks a
ChunksNil -> case SmallArray a
c of {SmallArray SmallArray# a
x -> SmallArray# a
x}
ChunksCons SmallArray a
d Chunks a
ds -> forall a. SmallArray a -> SmallArray# a
unSmallArray forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
let szc :: Int
szc = forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
c
szd :: Int
szd = forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
d
szboth :: Int
szboth = Int
szc forall a. Num a => a -> a -> a
+ Int
szd
len :: Int
len = forall a. Int -> Chunks a -> Int
chunksLengthGo Int
szboth Chunks a
ds
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len forall a. a
errorThunk
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
dst Int
0 SmallArray a
c Int
0 Int
szc
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
dst Int
szc SmallArray a
d Int
0 Int
szd
Int
_ <- forall s a. SmallMutableArray s a -> Int -> Chunks a -> ST s Int
copy SmallMutableArray s a
dst Int
szboth Chunks a
ds
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
concatReverse :: Chunks a -> SmallArray a
{-# inline concatReverse #-}
concatReverse :: forall a. Chunks a -> SmallArray a
concatReverse Chunks a
x = forall a. SmallArray# a -> SmallArray a
SmallArray (forall a. Chunks a -> SmallArray# a
concatReverse# Chunks a
x)
concatReverse# :: Chunks a -> SmallArray# a
{-# noinline concatReverse# #-}
concatReverse# :: forall a. Chunks a -> SmallArray# a
concatReverse# Chunks a
ChunksNil = case forall a. Monoid a => a
mempty of {SmallArray SmallArray# a
x -> SmallArray# a
x}
concatReverse# (ChunksCons SmallArray a
c Chunks a
cs) = case Chunks a
cs of
Chunks a
ChunksNil -> case SmallArray a
c of {SmallArray SmallArray# a
x -> SmallArray# a
x}
ChunksCons SmallArray a
d Chunks a
ds -> forall a. SmallArray a -> SmallArray# a
unSmallArray forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
let szc :: Int
szc = forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
c
szd :: Int
szd = forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
d
szboth :: Int
szboth = Int
szc forall a. Num a => a -> a -> a
+ Int
szd
len :: Int
len = forall a. Int -> Chunks a -> Int
chunksLengthGo Int
szboth Chunks a
ds
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len forall a. a
errorThunk
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
dst (Int
len forall a. Num a => a -> a -> a
- Int
szc) SmallArray a
c Int
0 Int
szc
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
dst (Int
len forall a. Num a => a -> a -> a
- (Int
szc forall a. Num a => a -> a -> a
+ Int
szd)) SmallArray a
d Int
0 Int
szd
Int
_ <- forall s a. SmallMutableArray s a -> Int -> Chunks a -> ST s Int
copyReverse SmallMutableArray s a
dst (Int
len forall a. Num a => a -> a -> a
- (Int
szc forall a. Num a => a -> a -> a
+ Int
szd)) Chunks a
ds
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
unSmallArray :: SmallArray a -> SmallArray# a
unSmallArray :: forall a. SmallArray a -> SmallArray# a
unSmallArray (SmallArray SmallArray# a
x) = SmallArray# a
x
errorThunk :: a
{-# noinline errorThunk #-}
errorThunk :: forall a. a
errorThunk = forall a. HasCallStack => String -> a
error String
"Data.Chunks: mistake"
map' :: (a -> b) -> Chunks a -> SmallArray b
{-# inline map' #-}
map' :: forall a b. (a -> b) -> Chunks a -> SmallArray b
map' a -> b
f Chunks a
cs = forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s b
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len forall a. a
errorThunk
!Int
_ <- forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
F.foldlM
( \ !Int
ix a
a -> do
let !b :: b
b = a -> b
f a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s b
dst Int
ix b
b
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix forall a. Num a => a -> a -> a
+ Int
1)
) Int
0 Chunks a
cs
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s b
dst
where
!len :: Int
len = forall a. Chunks a -> Int
chunksLength Chunks a
cs
construct1 :: a -> Chunks a
{-# inline construct1 #-}
construct1 :: forall a. a -> Chunks a
construct1 = forall a. a -> Chunks a
singleton
construct2 :: a -> a -> Chunks a
{-# inline construct2 #-}
construct2 :: forall a. a -> a -> Chunks a
construct2 = forall a. a -> a -> Chunks a
doubleton
construct3 :: a -> a -> a -> Chunks a
{-# inline construct3 #-}
construct3 :: forall a. a -> a -> a -> Chunks a
construct3 = forall a. a -> a -> a -> Chunks a
tripleton
construct4 :: a -> a -> a -> a -> Chunks a
{-# inline construct4 #-}
construct4 :: forall a. a -> a -> a -> a -> Chunks a
construct4 = forall a. a -> a -> a -> a -> Chunks a
quadrupleton
construct5 :: a -> a -> a -> a -> a -> Chunks a
{-# inline construct5 #-}
construct5 :: forall a. a -> a -> a -> a -> a -> Chunks a
construct5 = forall a. a -> a -> a -> a -> a -> Chunks a
quintupleton
construct6 :: a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct6 #-}
construct6 :: forall a. a -> a -> a -> a -> a -> a -> Chunks a
construct6 = forall a. a -> a -> a -> a -> a -> a -> Chunks a
sextupleton
construct7 :: a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct7 #-}
construct7 :: forall a. a -> a -> a -> a -> a -> a -> a -> Chunks a
construct7 = forall a. a -> a -> a -> a -> a -> a -> a -> Chunks a
septupleton
construct8 :: a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct8 #-}
construct8 :: forall a. a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
construct8 = forall a. a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
octupleton
construct9 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct9 #-}
construct9 :: forall a. a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
construct9 = forall a. a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
nonupleton
construct10 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct10 #-}
construct10 :: forall a.
a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
construct10 = forall a.
a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
decupleton
construct11 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct11 #-}
construct11 :: forall a.
a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
construct11 = forall a.
a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
undecupleton
construct12 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline construct12 #-}
construct12 :: forall a.
a
-> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
construct12 = forall a.
a
-> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
duodecupleton
singleton :: a -> Chunks a
{-# inline singleton #-}
singleton :: forall a. a -> Chunks a
singleton a
a = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST (forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
1 a
a forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray)
) forall a. Chunks a
ChunksNil
doubleton :: a -> a -> Chunks a
{-# inline doubleton #-}
doubleton :: forall a. a -> a -> Chunks a
doubleton a
a a
b = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
2 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
tripleton :: a -> a -> a -> Chunks a
{-# inline tripleton #-}
tripleton :: forall a. a -> a -> a -> Chunks a
tripleton a
a a
b a
c = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
3 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
quadrupleton :: a -> a -> a -> a -> Chunks a
{-# inline quadrupleton #-}
quadrupleton :: forall a. a -> a -> a -> a -> Chunks a
quadrupleton a
a a
b a
c a
d = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
4 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
quintupleton :: a -> a -> a -> a -> a -> Chunks a
{-# inline quintupleton #-}
quintupleton :: forall a. a -> a -> a -> a -> a -> Chunks a
quintupleton a
a a
b a
c a
d a
e = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
5 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
sextupleton :: a -> a -> a -> a -> a -> a -> Chunks a
{-# inline sextupleton #-}
sextupleton :: forall a. a -> a -> a -> a -> a -> a -> Chunks a
sextupleton a
a a
b a
c a
d a
e a
f = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
6 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
septupleton :: a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline septupleton #-}
septupleton :: forall a. a -> a -> a -> a -> a -> a -> a -> Chunks a
septupleton a
a a
b a
c a
d a
e a
f a
g = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
7 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
6 a
g
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
octupleton :: a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline octupleton #-}
octupleton :: forall a. a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
octupleton a
a a
b a
c a
d a
e a
f a
g a
h = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
8 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
6 a
g
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
7 a
h
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
nonupleton :: a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline nonupleton #-}
nonupleton :: forall a. a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
nonupleton a
a a
b a
c a
d a
e a
f a
g a
h a
i = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
9 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
6 a
g
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
7 a
h
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
8 a
i
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
decupleton :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline decupleton #-}
decupleton :: forall a.
a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
decupleton a
a a
b a
c a
d a
e a
f a
g a
h a
i a
j = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
10 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
6 a
g
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
7 a
h
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
8 a
i
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
9 a
j
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
undecupleton :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline undecupleton #-}
undecupleton :: forall a.
a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
undecupleton a
a a
b a
c a
d a
e a
f a
g a
h a
i a
j a
k = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
11 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
6 a
g
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
7 a
h
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
8 a
i
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
9 a
j
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
10 a
k
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil
duodecupleton :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
{-# inline duodecupleton #-}
duodecupleton :: forall a.
a
-> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
duodecupleton a
a a
b a
c a
d a
e a
f a
g a
h a
i a
j a
k a
l = forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
( forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST forall a b. (a -> b) -> a -> b
$ do
SmallMutableArray s a
dst <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
12 a
a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
1 a
b
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
2 a
c
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
3 a
d
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
4 a
e
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
5 a
f
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
6 a
g
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
7 a
h
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
8 a
i
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
9 a
j
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
10 a
k
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
dst Int
11 a
l
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
dst
) forall a. Chunks a
ChunksNil