{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE TypeFamilies #-}
{-# 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 (concat, null, reverse)

import Control.Monad.ST.Run (runSmallArrayST)
import Data.Primitive (SmallArray (..), SmallMutableArray (..))
import GHC.Exts (Int (I#), Int#, IsList, SmallArray#, SmallMutableArray#, State#, (+#), (-#))
import GHC.ST (ST (..))

import qualified Data.Foldable as F
import qualified Data.Primitive as PM
import qualified GHC.Exts as Exts

{- | 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
[Chunks a] -> ShowS
Chunks a -> String
(Int -> Chunks a -> ShowS)
-> (Chunks a -> String) -> ([Chunks a] -> ShowS) -> Show (Chunks a)
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
$cshowsPrec :: forall a. Show a => Int -> Chunks a -> ShowS
showsPrec :: Int -> Chunks a -> ShowS
$cshow :: forall a. Show a => Chunks a -> String
show :: Chunks a -> String
$cshowList :: forall a. Show a => [Chunks a] -> ShowS
showList :: [Chunks a] -> ShowS
Show)

instance (Eq a) => Eq (Chunks a) where
  == :: Chunks a -> Chunks a -> Bool
(==) = 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 = Chunks a -> [Item (Chunks a)]
Chunks a -> [SmallArray a]
forall a. Chunks a -> [SmallArray a]
chunksToSmallArrayList
  fromList :: [Item (Chunks a)] -> Chunks a
fromList [Item (Chunks a)]
xs = (SmallArray a -> Chunks a -> Chunks a)
-> Chunks a -> [SmallArray a] -> Chunks a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
F.foldr SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons Chunks a
forall a. Chunks a
ChunksNil [Item (Chunks a)]
[SmallArray a]
xs

-- | Are there any elements in the chunked list?
null :: Chunks a -> Bool
null :: forall a. Chunks a -> Bool
null = Chunks a -> Bool
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 SmallArray a -> Int
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 = Chunks a -> Int -> Maybe a
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
_ = Maybe a
forall a. Maybe a
Nothing
  go (ChunksCons SmallArray a
x Chunks a
xs) !Int
ix =
    let !len :: Int
len = SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
x
     in if Int
ix Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
len
          then case SmallArray a -> Int -> (# a #)
forall a. SmallArray a -> Int -> (# a #)
PM.indexSmallArray## SmallArray a
x Int
ix of
            (# a
v #) -> a -> Maybe a
forall a. a -> Maybe a
Just a
v
          else Chunks a -> Int -> Maybe a
go Chunks a
xs (Int
ix Int -> Int -> Int
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 SmallArray a -> [SmallArray a] -> [SmallArray a]
forall a. a -> [a] -> [a]
: Chunks a -> [SmallArray 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 = Chunks a -> Bool
forall a. Chunks a -> Bool
allEmpty Chunks a
cs
eqChunks (ChunksCons SmallArray a
x Chunks a
xs) Chunks a
cs = SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons SmallArray a
x Int
0 (SmallArray a -> Int
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 -> Chunks a -> Bool
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) =
  SmallArray a
-> Int
-> Int
-> SmallArray a
-> Int
-> Int
-> Chunks a
-> Chunks a
-> Bool
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 (SmallArray a -> Int
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 Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
xlen Int
ylen of
  Ordering
LT -> SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
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
&& SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons SmallArray a
yh (Int
yoff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
xlen) (Int
ylen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
xlen) Chunks a
yt Chunks a
xt
  Ordering
GT -> SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
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
&& SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
forall a.
Eq a =>
SmallArray a -> Int -> Int -> Chunks a -> Chunks a -> Bool
eqChunksCons SmallArray a
xh (Int
xoff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
ylen) (Int
xlen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
ylen) Chunks a
xt Chunks a
yt
  Ordering
EQ -> SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
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
&& Chunks a -> Chunks a -> 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 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Bool
True
  | Bool
otherwise =
      SmallArray a -> Int -> a
forall a. SmallArray a -> Int -> a
PM.indexSmallArray SmallArray a
xs Int
xoff a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== SmallArray a -> Int -> a
forall a. SmallArray a -> Int -> a
PM.indexSmallArray SmallArray a
ys Int
yoff
        Bool -> Bool -> Bool
&& SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
forall a.
Eq a =>
SmallArray a -> Int -> SmallArray a -> Int -> Int -> Bool
eqRange SmallArray a
xs (Int
xoff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) SmallArray a
ys (Int
yoff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int
len Int -> Int -> Int
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 SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
x of
  Int
0 -> Chunks a -> Bool
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
_) =
    Chunks a -> Chunks a -> Chunks a
forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto Chunks a
bs (Chunks a -> Chunks a
forall a. Chunks a -> Chunks a
reverse Chunks a
as)

instance Monoid (Chunks a) where
  mempty :: Chunks a
mempty = Chunks a
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' = (b -> a -> b) -> b -> Chunks a -> b
forall b a. (b -> a -> b) -> b -> Chunks a -> b
chunksFoldl'
  foldr :: forall a b. (a -> b -> b) -> b -> Chunks a -> b
foldr = (a -> b -> b) -> b -> Chunks a -> b
forall a b. (a -> b -> b) -> b -> Chunks a -> b
chunksFoldr
  length :: forall a. Chunks a -> Int
length = Chunks a -> Int
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 ((b -> a -> b) -> b -> SmallArray a -> b
forall b a. (b -> a -> b) -> b -> SmallArray a -> b
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) = (a -> b -> b) -> b -> SmallArray a -> b
forall a b. (a -> b -> b) -> b -> SmallArray a -> b
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 = Int -> Chunks a -> Int
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) =
  Int -> Chunks a -> Int
forall a. Int -> Chunks a -> Int
chunksLengthGo (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SmallArray a -> Int
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 = Chunks a -> Chunks a -> Chunks a
forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto Chunks a
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) =
  Chunks a -> Chunks a -> Chunks a
forall a. Chunks a -> Chunks a -> Chunks a
reverseOnto (SmallArray a -> Chunks a -> Chunks a
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 ::
  -- | Destination
  SmallMutableArray s a ->
  -- | Destination offset
  Int ->
  -- | Source
  Chunks a ->
  -- | Returns the next index into the destination after the payload
  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 =
  STRep s Int -> ST s Int
forall s a. STRep s a -> ST s a
ST
    ( \State# s
s0 -> case SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
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 = SmallArray# a -> Int#
forall a. SmallArray# a -> Int#
Exts.sizeofSmallArray# SmallArray# a
c
   in case SmallArray# a
-> Int#
-> SmallMutableArray# s a
-> Int#
-> Int#
-> State# s
-> State# s
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 -> SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
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 ::
  -- | Destination
  SmallMutableArray s a ->
  -- | Destination range successor
  Int ->
  -- | Source
  Chunks a ->
  -- | Returns the next index into the destination after the payload
  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 =
  STRep s Int -> ST s Int
forall s a. STRep s a -> ST s a
ST
    ( \State# s
s0 -> case SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
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 = SmallArray# a -> Int#
forall a. SmallArray# a -> Int#
Exts.sizeofSmallArray# SmallArray# a
c
      !off :: Int#
off = Int#
prevOff Int# -> Int# -> Int#
-# Int#
sz
   in case SmallArray# a
-> Int#
-> SmallMutableArray# s a
-> Int#
-> Int#
-> State# s
-> State# s
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 -> SmallMutableArray# s a
-> Int# -> Chunks a -> State# s -> (# State# s, Int# #)
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 = SmallArray# a -> SmallArray a
forall a. SmallArray# a -> SmallArray a
SmallArray (Chunks a -> SmallArray# a
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 SmallArray a
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 -> SmallArray a -> SmallArray# a
forall a. SmallArray a -> SmallArray# a
unSmallArray (SmallArray a -> SmallArray# a) -> SmallArray a -> SmallArray# a
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
    let szc :: Int
szc = SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
c
        szd :: Int
szd = SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
d
        szboth :: Int
szboth = Int
szc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
szd
        len :: Int
len = Int -> Chunks a -> Int
forall a. Int -> Chunks a -> Int
chunksLengthGo Int
szboth Chunks a
ds
    SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len a
forall a. a
errorThunk
    SmallMutableArray (PrimState (ST s)) a
-> Int -> SmallArray a -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
0 SmallArray a
c Int
0 Int
szc
    SmallMutableArray (PrimState (ST s)) a
-> Int -> SmallArray a -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
szc SmallArray a
d Int
0 Int
szd
    Int
_ <- SmallMutableArray s a -> Int -> Chunks a -> ST s Int
forall s a. SmallMutableArray s a -> Int -> Chunks a -> ST s Int
copy SmallMutableArray s a
dst Int
szboth Chunks a
ds
    SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst

concatReverse :: Chunks a -> SmallArray a
{-# INLINE concatReverse #-}
concatReverse :: forall a. Chunks a -> SmallArray a
concatReverse Chunks a
x = SmallArray# a -> SmallArray a
forall a. SmallArray# a -> SmallArray a
SmallArray (Chunks a -> SmallArray# a
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 SmallArray a
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 -> SmallArray a -> SmallArray# a
forall a. SmallArray a -> SmallArray# a
unSmallArray (SmallArray a -> SmallArray# a) -> SmallArray a -> SmallArray# a
forall a b. (a -> b) -> a -> b
$ (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
    let szc :: Int
szc = SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
c
        szd :: Int
szd = SmallArray a -> Int
forall a. SmallArray a -> Int
PM.sizeofSmallArray SmallArray a
d
        szboth :: Int
szboth = Int
szc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
szd
        len :: Int
len = Int -> Chunks a -> Int
forall a. Int -> Chunks a -> Int
chunksLengthGo Int
szboth Chunks a
ds
    SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len a
forall a. a
errorThunk
    SmallMutableArray (PrimState (ST s)) a
-> Int -> SmallArray a -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
szc) SmallArray a
c Int
0 Int
szc
    SmallMutableArray (PrimState (ST s)) a
-> Int -> SmallArray a -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
PM.copySmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
szc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
szd)) SmallArray a
d Int
0 Int
szd
    Int
_ <- SmallMutableArray s a -> Int -> Chunks a -> ST s Int
forall s a. SmallMutableArray s a -> Int -> Chunks a -> ST s Int
copyReverse SmallMutableArray s a
dst (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
szc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
szd)) Chunks a
ds
    SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST 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 = String -> a
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 s. ST s (SmallArray b)) -> SmallArray b
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray b)) -> SmallArray b)
-> (forall s. ST s (SmallArray b)) -> SmallArray b
forall a b. (a -> b) -> a -> b
$ do
  SmallMutableArray s b
dst <- Int -> b -> ST s (SmallMutableArray (PrimState (ST s)) b)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
len b
forall a. a
errorThunk
  !Int
_ <-
    (Int -> a -> ST s Int) -> Int -> Chunks a -> ST s 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
          SmallMutableArray (PrimState (ST s)) b -> Int -> b -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s b
SmallMutableArray (PrimState (ST s)) b
dst Int
ix b
b
          Int -> ST s Int
forall a. a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
      )
      Int
0
      Chunks a
cs
  SmallMutableArray (PrimState (ST s)) b -> ST s (SmallArray b)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s b
SmallMutableArray (PrimState (ST s)) b
dst
 where
  !len :: Int
len = Chunks a -> Int
forall a. Chunks a -> Int
chunksLength Chunks a
cs

construct1 :: a -> Chunks a
{-# INLINE construct1 #-}
construct1 :: forall a. a -> Chunks a
construct1 = a -> Chunks a
forall a. a -> Chunks a
singleton

construct2 :: a -> a -> Chunks a
{-# INLINE construct2 #-}
construct2 :: forall a. a -> a -> Chunks a
construct2 = a -> a -> Chunks a
forall a. a -> a -> Chunks a
doubleton

construct3 :: a -> a -> a -> Chunks a
{-# INLINE construct3 #-}
construct3 :: forall a. a -> a -> a -> Chunks a
construct3 = a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
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 = a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
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 = a
-> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST (Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
1 a
a ST s (SmallMutableArray s a)
-> (SmallMutableArray s a -> ST s (SmallArray a))
-> ST s (SmallArray a)
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SmallMutableArray s a -> ST s (SmallArray a)
SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray)
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
2 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
3 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
4 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
5 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
6 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
7 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
6 a
g
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
8 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
6 a
g
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
7 a
h
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
9 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
6 a
g
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
7 a
h
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
8 a
i
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
10 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
6 a
g
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
7 a
h
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
8 a
i
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
9 a
j
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
11 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
6 a
g
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
7 a
h
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
8 a
i
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
9 a
j
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
10 a
k
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
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 =
  SmallArray a -> Chunks a -> Chunks a
forall a. SmallArray a -> Chunks a -> Chunks a
ChunksCons
    ( (forall s. ST s (SmallArray a)) -> SmallArray a
forall a. (forall s. ST s (SmallArray a)) -> SmallArray a
runSmallArrayST ((forall s. ST s (SmallArray a)) -> SmallArray a)
-> (forall s. ST s (SmallArray a)) -> SmallArray a
forall a b. (a -> b) -> a -> b
$ do
        SmallMutableArray s a
dst <- Int -> a -> ST s (SmallMutableArray (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
PM.newSmallArray Int
12 a
a
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
1 a
b
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
2 a
c
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
3 a
d
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
4 a
e
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
5 a
f
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
6 a
g
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
7 a
h
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
8 a
i
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
9 a
j
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
10 a
k
        SmallMutableArray (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
PM.writeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst Int
11 a
l
        SmallMutableArray (PrimState (ST s)) a -> ST s (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
PM.unsafeFreezeSmallArray SmallMutableArray s a
SmallMutableArray (PrimState (ST s)) a
dst
    )
    Chunks a
forall a. Chunks a
ChunksNil