{-# language BangPatterns #-}
{-# language DerivingStrategies #-}
{-# language TypeFamilies #-}
{-# language MagicHash #-}
{-# language UnboxedTuples #-}

module Data.Chunks
  ( Chunks(..)
  , null
  , reverse
  , reverseOnto
  , copy
  , copyReverse
  , concat
  , concatReverse
    -- * Indexing
  , index
    -- * Traversals
  , map'
    -- * Construction
  , singleton
  , doubleton
  , tripleton
  , quadrupleton
  , quintupleton
  , sextupleton
  , septupleton
  , octupleton
  , nonupleton
  , decupleton
  , undecupleton
  , duodecupleton
    -- * Construction Alternate
  , 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

-- | A list of chunks. This is a foundation on top of
-- which efficient builder-like abstractions can be
-- implemented. There are no restrictions on the number
-- of elements in each chunk, although extremely small
-- chunks (singleton or doubleton chunks) may lead to
-- poor performance.
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

-- | Are there any elements in the chunked list?
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

-- | Indexing into the chunked list, returning @Nothing@ if there
-- are not enough elements.
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

-- The first argument chunk belongs to the first argument chunks.
-- It is its head. 
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 but not the elements within each
-- chunk.
--
-- >>> reverse [[42,17,94],[6,12],[3,14]]
-- [[3,14],[6,12],[42,17,94]]
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

-- | Variant of 'reverse' that allows the caller to provide
-- an initial list of chunks that the reversed chunks will
-- be pushed onto.
--
-- >>> reverseOnto [[15],[12,4]] [[42,17,94],[6,12],[3,14]]
-- [[3,14],[6,12],[42,17,94],[15],[12,4]]
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 the contents of the chunks into a mutable array.
-- Precondition: The destination must have enough space to
-- house the contents. This is not checked.
--
-- > dest (before): [x,x,x,x,x,x,x,x,x,x,x,x]
-- > copy dest 2 [[X,Y,Z],[A,B],[C,D]] (returns 9)
-- > dest (after):  [x,x,X,Y,Z,A,B,C,D,x,x,x]
copy ::
     SmallMutableArray s a -- ^ Destination
  -> Int -- ^ Destination offset
  -> Chunks a -- ^ Source
  -> ST s Int -- ^ Returns the next index into the destination after the payload
{-# 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

-- | Copy the contents of the chunks into a mutable array,
-- reversing the order of the chunks. Precondition: The
-- destination must have enough space to house the contents.
-- This is not checked.
--
-- > dest (before): [x,x,x,x,x,x,x,x,x,x,x,x]
-- > copyReverse dest 10 [[X,Y,Z],[A,B],[C,D]] (returns 3)
-- > dest (after):  [x,x,x,C,D,A,B,X,Y,Z,x,x]
copyReverse ::
     SmallMutableArray s a -- ^ Destination
  -> Int -- ^ Destination range successor
  -> Chunks a -- ^ Source
  -> ST s Int -- ^ Returns the next index into the destination after the payload
{-# 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"

-- | Mapping over chunks is a little unusual in that the result
-- is just a 'SmallArray'.
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

-- | Create chunks with 1 element.
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

-- | Create chunks with 2 elements.
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

-- | Create chunks with 3 elements.
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

-- | Create chunks with 4 elements.
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

-- | Create chunks with 5 elements.
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

-- | Create chunks with 6 elements.
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

-- | Create chunks with 7 elements.
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

-- | Create chunks with 8 elements.
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

-- | Create chunks with 9 elements.
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

-- | Create chunks with 10 elements.
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

-- | Create chunks with 11 elements.
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

-- | Create chunks with 12 elements.
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