{-# LANGUAGE CPP, MagicHash, UnboxedTuples, DeriveDataTypeable, BangPatterns #-}{-# LANGUAGE RankNTypes #-}{-# LANGUAGE TypeFamilies #-}{-# LANGUAGE TemplateHaskellQuotes #-}-- |-- Module : Data.Primitive.Array-- Copyright : (c) Roman Leshchinskiy 2009-2012-- License : BSD-style---- Maintainer : Roman Leshchinskiy <rl@cse.unsw.edu.au>-- Portability : non-portable---- Primitive arrays of boxed values.moduleData.Primitive.Array(Array (..),MutableArray (..),newArray ,readArray ,writeArray ,indexArray ,indexArrayM ,indexArray## ,freezeArray ,thawArray ,runArray ,createArray ,unsafeFreezeArray ,unsafeThawArray ,sameMutableArray ,copyArray ,copyMutableArray ,cloneArray ,cloneMutableArray ,sizeofArray ,sizeofMutableArray ,emptyArray ,fromListN,fromList,arrayFromListN ,arrayFromList ,mapArray' ,traverseArrayP )whereimportControl.DeepSeqimportControl.Monad.Primitive importGHC.Extshiding(toList)importqualifiedGHC.ExtsasExtsimportData.Typeable(Typeable)importData.Data(Data(..),DataType,mkDataType,mkNoRepType,Constr,mkConstr,Fixity(..),constrIndex)importControl.Monad.ST(ST,runST)importControl.ApplicativeimportControl.Monad(MonadPlus(..),when,liftM2)importqualifiedControl.Monad.FailasFailimportControl.Monad.FiximportqualifiedData.FoldableasFoldableimportControl.Monad.ZipimportData.Foldable(Foldable(..),toList)importqualifiedGHC.STasGHCSTimportqualifiedData.FoldableasFimportData.SemigroupimportData.Functor.Identity
#if !MIN_VERSION_base(4,10,0)
importGHC.Base(runRW#)
#endif
importText.Read(Read(..),parens,prec)importText.ParserCombinators.ReadPrec(ReadPrec)importqualifiedText.ParserCombinators.ReadPrecasRdPrcimportText.ParserCombinators.ReadPimportData.Functor.Classes(Eq1(..),Ord1(..),Show1(..),Read1(..))importLanguage.Haskell.TH.Syntax(Lift(..))-- | Boxed arrays.dataArray a =Array {forall a. Array a -> Array# a
array# ::Array#a }deriving(Typeable)instanceLifta =>Lift(Array a )where
#if MIN_VERSION_template_haskell(2,16,0)
liftTyped :: forall (m :: * -> *). Quote m => Array a -> Code m (Array a)
liftTypedArray a
ary =case[a]
lst of[]->[||Array(emptyArray#(##))||][a
x ]->[||pure$!x||]a
x :[a]
xs ->[||unsafeArrayFromListN'lenxxs||]
#else
liftary=caselstof[]->[|Array(emptyArray#(##))|][x]->[|pure$!x|]x:xs->[|unsafeArrayFromListN'lenxxs|]
#endif
wherelen :: Int
len =forall (t :: * -> *) a. Foldable t => t a -> Int
lengthArray a
ary lst :: [a]
lst =forall (t :: * -> *) a. Foldable t => t a -> [a]
toListArray a
ary -- | Strictly create an array from a nonempty list (represented as-- a first element and a list of the rest) of a known length. If the length-- of the list does not match the given length, this makes demons fly-- out of your nose. We use it in the 'Lift' instance. If you edit the-- splice and break it, you get to keep both pieces.unsafeArrayFromListN' ::Int->a ->[a ]->Array a unsafeArrayFromListN' :: forall a. Int -> a -> [a] -> Array a
unsafeArrayFromListN' Int
n a
y [a]
ys =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray Int
n a
y forall a b. (a -> b) -> a -> b
$\MutableArray s a
ma ->letgo :: Int -> [a] -> ST s ()
go !Int
_ix []=forall (m :: * -> *) a. Monad m => a -> m a
return()go !Int
ix (!a
x :[a]
xs )=doforall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s a
ma Int
ix a
x Int -> [a] -> ST s ()
go (Int
ix forall a. Num a => a -> a -> a
+Int
1)[a]
xs inInt -> [a] -> ST s ()
go Int
1[a]
ys 
#if MIN_VERSION_deepseq(1,4,3)
instanceNFData1Array whereliftRnf :: forall a. (a -> ()) -> Array a -> ()
liftRnfa -> ()
r =forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl'(\()
_->a -> ()
r )()
#endif
instanceNFDataa =>NFData(Array a )wherernf :: Array a -> ()
rnf=forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl'(\()
_->forall a. NFData a => a -> ()
rnf)()-- | Mutable boxed arrays associated with a primitive state token.dataMutableArray s a =MutableArray {forall s a. MutableArray s a -> MutableArray# s a
marray# ::MutableArray#s a }deriving(Typeable)-- | The number of elements in an immutable array.sizeofArray ::Array a ->IntsizeofArray :: forall a. Array a -> Int
sizeofArray Array a
a =Int# -> Int
I#(forall a. Array# a -> Int#
sizeofArray#(forall a. Array a -> Array# a
array# Array a
a )){-# INLINEsizeofArray #-}-- | The number of elements in a mutable array.sizeofMutableArray ::MutableArray s a ->IntsizeofMutableArray :: forall s a. MutableArray s a -> Int
sizeofMutableArray MutableArray s a
a =Int# -> Int
I#(forall d a. MutableArray# d a -> Int#
sizeofMutableArray#(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray s a
a )){-# INLINEsizeofMutableArray #-}-- | Create a new mutable array of the specified size and initialise all-- elements with the given value.---- /Note:/ this function does not check if the input is non-negative.newArray ::PrimMonad m =>Int->a ->m (MutableArray (PrimState m )a ){-# INLINEnewArray #-}newArray :: forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray (I#Int#
n# )a
x =forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive (\State# (PrimState m)
s# ->caseforall a d.
Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
newArray#Int#
n# a
x State# (PrimState m)
s# of(#State# (PrimState m)
s'# ,MutableArray# (PrimState m) a
arr# #)->letma :: MutableArray (PrimState m) a
ma =forall s a. MutableArray# s a -> MutableArray s a
MutableArray MutableArray# (PrimState m) a
arr# in(#State# (PrimState m)
s'# ,MutableArray (PrimState m) a
ma #))-- | Read a value from the array at the given index.---- /Note:/ this function does not do bounds checking.readArray ::PrimMonad m =>MutableArray (PrimState m )a ->Int->m a {-# INLINEreadArray #-}readArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr (I#Int#
i# )=forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive (forall d a.
MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
readArray#(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray (PrimState m) a
arr )Int#
i# )-- | Write a value to the array at the given index.---- /Note:/ this function does not do bounds checking.writeArray ::PrimMonad m =>MutableArray (PrimState m )a ->Int->a ->m (){-# INLINEwriteArray #-}writeArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arr (I#Int#
i# )a
x =forall (m :: * -> *).
PrimMonad m =>
(State# (PrimState m) -> State# (PrimState m)) -> m ()
primitive_ (forall d a. MutableArray# d a -> Int# -> a -> State# d -> State# d
writeArray#(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray (PrimState m) a
arr )Int#
i# a
x )-- | Read a value from the immutable array at the given index.---- /Note:/ this function does not do bounds checking.indexArray ::Array a ->Int->a {-# INLINEindexArray #-}indexArray :: forall a. Array a -> Int -> a
indexArray Array a
arr (I#Int#
i# )=caseforall a. Array# a -> Int# -> (# a #)
indexArray#(forall a. Array a -> Array# a
array# Array a
arr )Int#
i# of(#a
x #)->a
x -- | Read a value from the immutable array at the given index, returning-- the result in an unboxed unary tuple. This is currently used to implement-- folds.---- /Note:/ this function does not do bounds checking.indexArray## ::Array a ->Int->(#a #)indexArray## :: forall a. Array a -> Int -> (# a #)
indexArray## Array a
arr (I#Int#
i )=forall a. Array# a -> Int# -> (# a #)
indexArray#(forall a. Array a -> Array# a
array# Array a
arr )Int#
i {-# INLINEindexArray## #-}-- | Monadically read a value from the immutable array at the given index.-- This allows us to be strict in the array while remaining lazy in the read-- element which is very useful for collective operations. Suppose we want to-- copy an array. We could do something like this:---- > copy marr arr ... = do ...-- > writeArray marr i (indexArray arr i) ...-- > ...---- But since the arrays are lazy, the calls to 'indexArray' will not be-- evaluated. Rather, @marr@ will be filled with thunks each of which would-- retain a reference to @arr@. This is definitely not what we want!---- With 'indexArrayM', we can instead write---- > copy marr arr ... = do ...-- > x <- indexArrayM arr i-- > writeArray marr i x-- > ...---- Now, indexing is executed immediately although the returned element is-- still not evaluated.---- /Note:/ this function does not do bounds checking.indexArrayM ::Monadm =>Array a ->Int->m a {-# INLINEindexArrayM #-}indexArrayM :: forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
arr (I#Int#
i# )=caseforall a. Array# a -> Int# -> (# a #)
indexArray#(forall a. Array a -> Array# a
array# Array a
arr )Int#
i# of(#a
x #)->forall (m :: * -> *) a. Monad m => a -> m a
returna
x -- | Create an immutable copy of a slice of an array.---- This operation makes a copy of the specified section, so it is safe to-- continue using the mutable array afterward.---- /Note:/ The provided array should contain the full subrange-- specified by the two Ints, but this is not checked.freezeArray ::PrimMonad m =>MutableArray (PrimState m )a -- ^ source->Int-- ^ offset->Int-- ^ length->m (Array a ){-# INLINEfreezeArray #-}freezeArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> Int -> m (Array a)
freezeArray (MutableArray MutableArray# (PrimState m) a
ma# )(I#Int#
off# )(I#Int#
len# )=forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive forall a b. (a -> b) -> a -> b
$\State# (PrimState m)
s ->caseforall d a.
MutableArray# d a
-> Int# -> Int# -> State# d -> (# State# d, Array# a #)
freezeArray#MutableArray# (PrimState m) a
ma# Int#
off# Int#
len# State# (PrimState m)
s of(#State# (PrimState m)
s' ,Array# a
a# #)->(#State# (PrimState m)
s' ,forall a. Array# a -> Array a
Array Array# a
a# #)-- | Convert a mutable array to an immutable one without copying. The-- array should not be modified after the conversion.unsafeFreezeArray ::PrimMonad m =>MutableArray (PrimState m )a ->m (Array a ){-# INLINEunsafeFreezeArray #-}unsafeFreezeArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray MutableArray (PrimState m) a
arr =forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive (\State# (PrimState m)
s# ->caseforall d a.
MutableArray# d a -> State# d -> (# State# d, Array# a #)
unsafeFreezeArray#(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray (PrimState m) a
arr )State# (PrimState m)
s# of(#State# (PrimState m)
s'# ,Array# a
arr'# #)->leta :: Array a
a =forall a. Array# a -> Array a
Array Array# a
arr'# in(#State# (PrimState m)
s'# ,Array a
a #))-- | Create a mutable array from a slice of an immutable array.---- This operation makes a copy of the specified slice, so it is safe to use the-- immutable array afterward.---- /Note:/ The provided array should contain the full subrange-- specified by the two Ints, but this is not checked.thawArray ::PrimMonad m =>Array a -- ^ source->Int-- ^ offset->Int-- ^ length->m (MutableArray (PrimState m )a ){-# INLINEthawArray #-}thawArray :: forall (m :: * -> *) a.
PrimMonad m =>
Array a -> Int -> Int -> m (MutableArray (PrimState m) a)
thawArray (Array Array# a
a# )(I#Int#
off# )(I#Int#
len# )=forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive forall a b. (a -> b) -> a -> b
$\State# (PrimState m)
s ->caseforall a d.
Array# a
-> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
thawArray#Array# a
a# Int#
off# Int#
len# State# (PrimState m)
s of(#State# (PrimState m)
s' ,MutableArray# (PrimState m) a
ma# #)->(#State# (PrimState m)
s' ,forall s a. MutableArray# s a -> MutableArray s a
MutableArray MutableArray# (PrimState m) a
ma# #)-- | Convert an immutable array to an mutable one without copying. The-- immutable array should not be used after the conversion.unsafeThawArray ::PrimMonad m =>Array a ->m (MutableArray (PrimState m )a ){-# INLINEunsafeThawArray #-}unsafeThawArray :: forall (m :: * -> *) a.
PrimMonad m =>
Array a -> m (MutableArray (PrimState m) a)
unsafeThawArray Array a
a =forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive (\State# (PrimState m)
s# ->caseforall a d.
Array# a -> State# d -> (# State# d, MutableArray# d a #)
unsafeThawArray#(forall a. Array a -> Array# a
array# Array a
a )State# (PrimState m)
s# of(#State# (PrimState m)
s'# ,MutableArray# (PrimState m) a
arr'# #)->letma :: MutableArray (PrimState m) a
ma =forall s a. MutableArray# s a -> MutableArray s a
MutableArray MutableArray# (PrimState m) a
arr'# in(#State# (PrimState m)
s'# ,MutableArray (PrimState m) a
ma #))-- | Check whether the two arrays refer to the same memory block.sameMutableArray ::MutableArray s a ->MutableArray s a ->Bool{-# INLINEsameMutableArray #-}sameMutableArray :: forall s a. MutableArray s a -> MutableArray s a -> Bool
sameMutableArray MutableArray s a
arr MutableArray s a
brr =Int# -> Bool
isTrue#(forall d a. MutableArray# d a -> MutableArray# d a -> Int#
sameMutableArray#(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray s a
arr )(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray s a
brr ))-- | Copy a slice of an immutable array to a mutable array.---- /Note:/ this function does not do bounds or overlap checking.copyArray ::PrimMonad m =>MutableArray (PrimState m )a -- ^ destination array->Int-- ^ offset into destination array->Array a -- ^ source array->Int-- ^ offset into source array->Int-- ^ number of elements to copy->m (){-# INLINEcopyArray #-}copyArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray (MutableArray MutableArray# (PrimState m) a
dst# )(I#Int#
doff# )(Array Array# a
src# )(I#Int#
soff# )(I#Int#
len# )=forall (m :: * -> *).
PrimMonad m =>
(State# (PrimState m) -> State# (PrimState m)) -> m ()
primitive_ (forall a d.
Array# a
-> Int#
-> MutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copyArray#Array# a
src# Int#
soff# MutableArray# (PrimState m) a
dst# Int#
doff# Int#
len# )-- | Copy a slice of a mutable array to another array. The two arrays may overlap.---- /Note:/ this function does not do bounds or overlap checking.copyMutableArray ::PrimMonad m =>MutableArray (PrimState m )a -- ^ destination array->Int-- ^ offset into destination array->MutableArray (PrimState m )a -- ^ source array->Int-- ^ offset into source array->Int-- ^ number of elements to copy->m (){-# INLINEcopyMutableArray #-}copyMutableArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> MutableArray (PrimState m) a -> Int -> Int -> m ()
copyMutableArray (MutableArray MutableArray# (PrimState m) a
dst# )(I#Int#
doff# )(MutableArray MutableArray# (PrimState m) a
src# )(I#Int#
soff# )(I#Int#
len# )=forall (m :: * -> *).
PrimMonad m =>
(State# (PrimState m) -> State# (PrimState m)) -> m ()
primitive_ (forall d a.
MutableArray# d a
-> Int#
-> MutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copyMutableArray#MutableArray# (PrimState m) a
src# Int#
soff# MutableArray# (PrimState m) a
dst# Int#
doff# Int#
len# )-- | Return a newly allocated 'Array' with the specified subrange of the-- provided 'Array'.---- /Note:/ The provided array should contain the full subrange-- specified by the two Ints, but this is not checked.cloneArray ::Array a -- ^ source array->Int-- ^ offset into destination array->Int-- ^ number of elements to copy->Array a {-# INLINEcloneArray #-}cloneArray :: forall a. Array a -> Int -> Int -> Array a
cloneArray (Array Array# a
arr# )(I#Int#
off# )(I#Int#
len# )=caseforall a. Array# a -> Int# -> Int# -> Array# a
cloneArray#Array# a
arr# Int#
off# Int#
len# ofArray# a
arr'# ->forall a. Array# a -> Array a
Array Array# a
arr'# -- | Return a newly allocated 'MutableArray'. with the specified subrange of-- the provided 'MutableArray'. The provided 'MutableArray' should contain the-- full subrange specified by the two Ints, but this is not checked.---- /Note:/ The provided array should contain the full subrange-- specified by the two Ints, but this is not checked.cloneMutableArray ::PrimMonad m =>MutableArray (PrimState m )a -- ^ source array->Int-- ^ offset into destination array->Int-- ^ number of elements to copy->m (MutableArray (PrimState m )a ){-# INLINEcloneMutableArray #-}cloneMutableArray :: forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Int -> m (MutableArray (PrimState m) a)
cloneMutableArray (MutableArray MutableArray# (PrimState m) a
arr# )(I#Int#
off# )(I#Int#
len# )=forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive (\State# (PrimState m)
s# ->caseforall d a.
MutableArray# d a
-> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
cloneMutableArray#MutableArray# (PrimState m) a
arr# Int#
off# Int#
len# State# (PrimState m)
s# of(#State# (PrimState m)
s'# ,MutableArray# (PrimState m) a
arr'# #)->(#State# (PrimState m)
s'# ,forall s a. MutableArray# s a -> MutableArray s a
MutableArray MutableArray# (PrimState m) a
arr'# #))-- | The empty 'Array'.emptyArray ::Array a emptyArray :: forall a. Array a
emptyArray =forall a. (forall s. ST s a) -> a
runSTforall a b. (a -> b) -> a -> b
$forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
0(forall a. String -> String -> a
die String
"emptyArray"String
"impossible")forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray {-# NOINLINEemptyArray #-}-- | Execute the monadic action and freeze the resulting array.---- > runArray m = runST $ m >>= unsafeFreezeArrayrunArray ::(foralls .STs (MutableArray s a ))->Array a runArray :: forall a. (forall s. ST s (MutableArray s a)) -> Array a
runArray forall s. ST s (MutableArray s a)
m =forall a. Array# a -> Array a
Array (forall a. (forall s. ST s (MutableArray s a)) -> Array# a
runArray# forall s. ST s (MutableArray s a)
m )runArray# ::(foralls .STs (MutableArray s a ))->Array#a runArray# :: forall a. (forall s. ST s (MutableArray s a)) -> Array# a
runArray# forall s. ST s (MutableArray s a)
m =caseforall o. (State# RealWorld -> o) -> o
runRW#forall a b. (a -> b) -> a -> b
$\State# RealWorld
s ->caseforall s a. ST s a -> State# s -> (# State# s, a #)
unST forall s. ST s (MutableArray s a)
m State# RealWorld
s of{(#State# RealWorld
s' ,MutableArray MutableArray# RealWorld a
mary# #)->forall d a.
MutableArray# d a -> State# d -> (# State# d, Array# a #)
unsafeFreezeArray#MutableArray# RealWorld a
mary# State# RealWorld
s' }of(#State# RealWorld
_,Array# a
ary# #)->Array# a
ary# unST ::STs a ->State#s ->(#State#s ,a #)unST :: forall s a. ST s a -> State# s -> (# State# s, a #)
unST (GHCST.STSTRep s a
f )=STRep s a
f emptyArray# ::(##)->Array#a emptyArray# :: forall a. (# #) -> Array# a
emptyArray# (# #)
_=caseforall a. Array a
emptyArray ofArray Array# a
ar ->Array# a
ar {-# NOINLINEemptyArray# #-}-- | Create an array of the given size with a default value,-- apply the monadic function and freeze the result. If the-- size is 0, return 'emptyArray' (rather than a new copy thereof).---- > createArray 0 _ _ = emptyArray-- > createArray n x f = runArray $ do-- > mary <- newArray n x-- > f mary-- > pure marycreateArray ::Int->a ->(foralls .MutableArray s a ->STs ())->Array a -- This low-level business is designed to work with GHC's worker-wrapper-- transformation. A lot of the time, we don't actually need an Array-- constructor. By putting it on the outside, and being careful about-- how we special-case the empty array, we can make GHC smarter about this.-- The only downside is that separately created 0-length arrays won't share-- their Array constructors, although they'll share their underlying-- Array#s.createArray :: forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray Int
0a
_forall s. MutableArray s a -> ST s ()
_=forall a. Array# a -> Array a
Array (forall a. (# #) -> Array# a
emptyArray# (##))createArray Int
n a
x forall s. MutableArray s a -> ST s ()
f =forall a. (forall s. ST s (MutableArray s a)) -> Array a
runArray forall a b. (a -> b) -> a -> b
$doMutableArray s a
mary <-forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
n a
x forall s. MutableArray s a -> ST s ()
f MutableArray s a
mary forall (f :: * -> *) a. Applicative f => a -> f a
pureMutableArray s a
mary die ::String->String->a die :: forall a. String -> String -> a
die String
fun String
problem =forall a. HasCallStack => String -> a
errorforall a b. (a -> b) -> a -> b
$String
"Data.Primitive.Array."forall a. [a] -> [a] -> [a]
++String
fun forall a. [a] -> [a] -> [a]
++String
": "forall a. [a] -> [a] -> [a]
++String
problem arrayLiftEq ::(a ->b ->Bool)->Array a ->Array b ->BoolarrayLiftEq :: forall a b. (a -> b -> Bool) -> Array a -> Array b -> Bool
arrayLiftEq a -> b -> Bool
p Array a
a1 Array b
a2 =forall a. Array a -> Int
sizeofArray Array a
a1 forall a. Eq a => a -> a -> Bool
==forall a. Array a -> Int
sizeofArray Array b
a2 Bool -> Bool -> Bool
&&Int -> Bool
loop (forall a. Array a -> Int
sizeofArray Array a
a1 forall a. Num a => a -> a -> a
-Int
1)whereloop :: Int -> Bool
loop Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
0=Bool
True|(#a
x1 #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
a1 Int
i ,(#b
x2 #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array b
a2 Int
i ,Bool
otherwise=a -> b -> Bool
p a
x1 b
x2 Bool -> Bool -> Bool
&&Int -> Bool
loop (Int
i forall a. Num a => a -> a -> a
-Int
1)instanceEqa =>Eq(Array a )whereArray a
a1 == :: Array a -> Array a -> Bool
==Array a
a2 =forall a b. (a -> b -> Bool) -> Array a -> Array b -> Bool
arrayLiftEq forall a. Eq a => a -> a -> Bool
(==)Array a
a1 Array a
a2 -- | @since 0.6.4.0instanceEq1Array whereliftEq :: forall a b. (a -> b -> Bool) -> Array a -> Array b -> Bool
liftEq=forall a b. (a -> b -> Bool) -> Array a -> Array b -> Bool
arrayLiftEq instanceEq(MutableArray s a )whereMutableArray s a
ma1 == :: MutableArray s a -> MutableArray s a -> Bool
==MutableArray s a
ma2 =Int# -> Bool
isTrue#(forall d a. MutableArray# d a -> MutableArray# d a -> Int#
sameMutableArray#(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray s a
ma1 )(forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray s a
ma2 ))arrayLiftCompare ::(a ->b ->Ordering)->Array a ->Array b ->OrderingarrayLiftCompare :: forall a b. (a -> b -> Ordering) -> Array a -> Array b -> Ordering
arrayLiftCompare a -> b -> Ordering
elemCompare Array a
a1 Array b
a2 =Int -> Ordering
loop Int
0wheremn :: Int
mn =forall a. Array a -> Int
sizeofArray Array a
a1 forall a. Ord a => a -> a -> a
`min`forall a. Array a -> Int
sizeofArray Array b
a2 loop :: Int -> Ordering
loop Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
mn ,(#a
x1 #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
a1 Int
i ,(#b
x2 #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array b
a2 Int
i =a -> b -> Ordering
elemCompare a
x1 b
x2 forall a. Monoid a => a -> a -> a
`mappend`Int -> Ordering
loop (Int
i forall a. Num a => a -> a -> a
+Int
1)|Bool
otherwise=forall a. Ord a => a -> a -> Ordering
compare(forall a. Array a -> Int
sizeofArray Array a
a1 )(forall a. Array a -> Int
sizeofArray Array b
a2 )-- | Lexicographic ordering. Subject to change between major versions.instanceOrda =>Ord(Array a )wherecompare :: Array a -> Array a -> Ordering
compare Array a
a1 Array a
a2 =forall a b. (a -> b -> Ordering) -> Array a -> Array b -> Ordering
arrayLiftCompare forall a. Ord a => a -> a -> Ordering
compareArray a
a1 Array a
a2 -- | @since 0.6.4.0instanceOrd1Array whereliftCompare :: forall a b. (a -> b -> Ordering) -> Array a -> Array b -> Ordering
liftCompare=forall a b. (a -> b -> Ordering) -> Array a -> Array b -> Ordering
arrayLiftCompare instanceFoldableArray where-- Note: we perform the array lookups eagerly so we won't-- create thunks to perform lookups even if GHC can't see-- that the folding function is strict.foldr :: forall a b. (a -> b -> b) -> b -> Array a -> b
foldra -> b -> b
f =\b
z !Array a
ary ->let!sz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary go :: Int -> b
go Int
i |Int
i forall a. Eq a => a -> a -> Bool
==Int
sz =b
z |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =a -> b -> b
f a
x (Int -> b
go (Int
i forall a. Num a => a -> a -> a
+Int
1))inInt -> b
go Int
0{-# INLINEfoldr#-}foldl :: forall b a. (b -> a -> b) -> b -> Array a -> b
foldlb -> a -> b
f =\b
z !Array a
ary ->letgo :: Int -> b
go Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
0=b
z |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =b -> a -> b
f (Int -> b
go (Int
i forall a. Num a => a -> a -> a
-Int
1))a
x inInt -> b
go (forall a. Array a -> Int
sizeofArray Array a
ary forall a. Num a => a -> a -> a
-Int
1){-# INLINEfoldl#-}foldr1 :: forall a. (a -> a -> a) -> Array a -> a
foldr1a -> a -> a
f =\!Array a
ary ->let!sz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary forall a. Num a => a -> a -> a
-Int
1go :: Int -> a
go Int
i =caseforall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i of(#a
x #)|Int
i forall a. Eq a => a -> a -> Bool
==Int
sz ->a
x |Bool
otherwise->a -> a -> a
f a
x (Int -> a
go (Int
i forall a. Num a => a -> a -> a
+Int
1))inifInt
sz forall a. Ord a => a -> a -> Bool
<Int
0thenforall a. String -> String -> a
die String
"foldr1"String
"empty array"elseInt -> a
go Int
0{-# INLINEfoldr1#-}foldl1 :: forall a. (a -> a -> a) -> Array a -> a
foldl1a -> a -> a
f =\!Array a
ary ->let!sz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary forall a. Num a => a -> a -> a
-Int
1go :: Int -> a
go Int
i =caseforall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i of(#a
x #)|Int
i forall a. Eq a => a -> a -> Bool
==Int
0->a
x |Bool
otherwise->a -> a -> a
f (Int -> a
go (Int
i forall a. Num a => a -> a -> a
-Int
1))a
x inifInt
sz forall a. Ord a => a -> a -> Bool
<Int
0thenforall a. String -> String -> a
die String
"foldl1"String
"empty array"elseInt -> a
go Int
sz {-# INLINEfoldl1#-}foldr' :: forall a b. (a -> b -> b) -> b -> Array a -> b
foldr'a -> b -> b
f =\b
z !Array a
ary ->letgo :: Int -> b -> b
go Int
i !b
acc |Int
i forall a. Eq a => a -> a -> Bool
==-Int
1=b
acc |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =Int -> b -> b
go (Int
i forall a. Num a => a -> a -> a
-Int
1)(a -> b -> b
f a
x b
acc )inInt -> b -> b
go (forall a. Array a -> Int
sizeofArray Array a
ary forall a. Num a => a -> a -> a
-Int
1)b
z {-# INLINEfoldr'#-}foldl' :: forall b a. (b -> a -> b) -> b -> Array a -> b
foldl' b -> a -> b
f =\b
z !Array a
ary ->let!sz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary go :: Int -> b -> b
go Int
i !b
acc |Int
i forall a. Eq a => a -> a -> Bool
==Int
sz =b
acc |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =Int -> b -> b
go (Int
i forall a. Num a => a -> a -> a
+Int
1)(b -> a -> b
f b
acc a
x )inInt -> b -> b
go Int
0b
z {-# INLINEfoldl'#-}null :: forall a. Array a -> Bool
nullArray a
a =forall a. Array a -> Int
sizeofArray Array a
a forall a. Eq a => a -> a -> Bool
==Int
0{-# INLINEnull#-}length :: forall a. Array a -> Int
length =forall a. Array a -> Int
sizeofArray {-# INLINElength#-}maximum :: forall a. Ord a => Array a -> a
maximumArray a
ary |Int
sz forall a. Eq a => a -> a -> Bool
==Int
0=forall a. String -> String -> a
die String
"maximum"String
"empty array"|(#a
frst #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
0=Int -> a -> a
go Int
1a
frst wheresz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary go :: Int -> a -> a
go Int
i !a
e |Int
i forall a. Eq a => a -> a -> Bool
==Int
sz =a
e |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =Int -> a -> a
go (Int
i forall a. Num a => a -> a -> a
+Int
1)(forall a. Ord a => a -> a -> a
maxa
e a
x ){-# INLINEmaximum#-}minimum :: forall a. Ord a => Array a -> a
minimumArray a
ary |Int
sz forall a. Eq a => a -> a -> Bool
==Int
0=forall a. String -> String -> a
die String
"minimum"String
"empty array"|(#a
frst #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
0=Int -> a -> a
go Int
1a
frst wheresz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary go :: Int -> a -> a
go Int
i !a
e |Int
i forall a. Eq a => a -> a -> Bool
==Int
sz =a
e |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =Int -> a -> a
go (Int
i forall a. Num a => a -> a -> a
+Int
1)(forall a. Ord a => a -> a -> a
mina
e a
x ){-# INLINEminimum#-}sum :: forall a. Num a => Array a -> a
sum=forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl'forall a. Num a => a -> a -> a
(+)a
0{-# INLINEsum#-}product :: forall a. Num a => Array a -> a
product=forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl'forall a. Num a => a -> a -> a
(*)a
1{-# INLINEproduct#-}newtypeSTA a =STA {forall a. STA a -> forall s. MutableArray# s a -> ST s (Array a)
_runSTA ::foralls .MutableArray#s a ->STs (Array a )}runSTA ::Int->STA a ->Array a runSTA :: forall a. Int -> STA a -> Array a
runSTA !Int
sz =\(STA forall s. MutableArray# s a -> ST s (Array a)
m )->forall a. (forall s. ST s a) -> a
runSTforall a b. (a -> b) -> a -> b
$forall s a. Int -> ST s (MutableArray s a)
newArray_ Int
sz forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=\MutableArray s a
ar ->forall s. MutableArray# s a -> ST s (Array a)
m (forall s a. MutableArray s a -> MutableArray# s a
marray# MutableArray s a
ar ){-# INLINErunSTA #-}newArray_ ::Int->STs (MutableArray s a )newArray_ :: forall s a. Int -> ST s (MutableArray s a)
newArray_ !Int
n =forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
n forall a. a
badTraverseValue badTraverseValue ::a badTraverseValue :: forall a. a
badTraverseValue =forall a. String -> String -> a
die String
"traverse"String
"bad indexing"{-# NOINLINEbadTraverseValue #-}instanceTraversableArray wheretraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Array a -> f (Array b)
traversea -> f b
f =forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Array a -> f (Array b)
traverseArray a -> f b
f {-# INLINEtraverse#-}traverseArray ::Applicativef =>(a ->f b )->Array a ->f (Array b )traverseArray :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Array a -> f (Array b)
traverseArray a -> f b
f =\!Array a
ary ->let!len :: Int
len =forall a. Array a -> Int
sizeofArray Array a
ary go :: Int -> f (STA b)
go !Int
i |Int
i forall a. Eq a => a -> a -> Bool
==Int
len =forall (f :: * -> *) a. Applicative f => a -> f a
pureforall a b. (a -> b) -> a -> b
$forall a. (forall s. MutableArray# s a -> ST s (Array a)) -> STA a
STA forall a b. (a -> b) -> a -> b
$\MutableArray# s b
mary ->forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray (forall s a. MutableArray# s a -> MutableArray s a
MutableArray MutableArray# s b
mary )|(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i =forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2(\b
b (STA forall s. MutableArray# s b -> ST s (Array b)
m )->forall a. (forall s. MutableArray# s a -> ST s (Array a)) -> STA a
STA forall a b. (a -> b) -> a -> b
$\MutableArray# s b
mary ->forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray (forall s a. MutableArray# s a -> MutableArray s a
MutableArray MutableArray# s b
mary )Int
i b
b forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>forall s. MutableArray# s b -> ST s (Array b)
m MutableArray# s b
mary )(a -> f b
f a
x )(Int -> f (STA b)
go (Int
i forall a. Num a => a -> a -> a
+Int
1))inifInt
len forall a. Eq a => a -> a -> Bool
==Int
0thenforall (f :: * -> *) a. Applicative f => a -> f a
pureforall a. Array a
emptyArray elseforall a. Int -> STA a -> Array a
runSTA Int
len forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>Int -> f (STA b)
go Int
0{-# INLINE[1]traverseArray #-}{-# RULES"traverse/ST"forall(f ::a ->STs b ).traverseArray f =traverseArrayP f "traverse/IO"forall(f ::a ->IOb ).traverseArray f =traverseArrayP f "traverse/Id"forall(f ::a ->Identityb ).traverseArray f =(coerce::(Array a ->Array (Identityb ))->Array a ->Identity(Array b ))(fmapf )#-}-- | This is the fastest, most straightforward way to traverse-- an array, but it only works correctly with a sufficiently-- "affine" 'PrimMonad' instance. In particular, it must only produce-- /one/ result array. 'Control.Monad.Trans.List.ListT'-transformed-- monads, for example, will not work right at all.traverseArrayP ::PrimMonad m =>(a ->m b )->Array a ->m (Array b )traverseArrayP :: forall (m :: * -> *) a b.
PrimMonad m =>
(a -> m b) -> Array a -> m (Array b)
traverseArrayP a -> m b
f =\!Array a
ary ->let!sz :: Int
sz =forall a. Array a -> Int
sizeofArray Array a
ary go :: Int -> MutableArray (PrimState m) b -> m (Array b)
go !Int
i !MutableArray (PrimState m) b
mary |Int
i forall a. Eq a => a -> a -> Bool
==Int
sz =forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray MutableArray (PrimState m) b
mary |Bool
otherwise=doa
a <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
ary Int
i b
b <-a -> m b
f a
a forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) b
mary Int
i b
b Int -> MutableArray (PrimState m) b -> m (Array b)
go (Int
i forall a. Num a => a -> a -> a
+Int
1)MutableArray (PrimState m) b
mary indoMutableArray (PrimState m) b
mary <-forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
sz forall a. a
badTraverseValue Int -> MutableArray (PrimState m) b -> m (Array b)
go Int
0MutableArray (PrimState m) b
mary {-# INLINEtraverseArrayP #-}-- | Strict map over the elements of the array.mapArray' ::(a ->b )->Array a ->Array b mapArray' :: forall a b. (a -> b) -> Array a -> Array b
mapArray' a -> b
f Array a
a =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (forall a. Array a -> Int
sizeofArray Array a
a )(forall a. String -> String -> a
die String
"mapArray'"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s b
mb ->letgo :: Int -> ST s ()
go Int
i |Int
i forall a. Eq a => a -> a -> Bool
==forall a. Array a -> Int
sizeofArray Array a
a =forall (m :: * -> *) a. Monad m => a -> m a
return()|Bool
otherwise=doa
x <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
a Int
i -- We use indexArrayM here so that we will perform the-- indexing eagerly even if f is lazy.let!y :: b
y =a -> b
f a
x forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s b
mb Int
i b
y forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)inInt -> ST s ()
go Int
0{-# INLINEmapArray' #-}-- | Create an array from a list of a known length. If the length-- of the list does not match the given length, this throws an exception.arrayFromListN ::Int->[a ]->Array a arrayFromListN :: forall a. Int -> [a] -> Array a
arrayFromListN Int
n [a]
l =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray Int
n (forall a. String -> String -> a
die String
"fromListN"String
"uninitialized element")forall a b. (a -> b) -> a -> b
$\MutableArray s a
sma ->letgo :: Int -> [a] -> ST s ()
go !Int
ix []=ifInt
ix forall a. Eq a => a -> a -> Bool
==Int
n thenforall (m :: * -> *) a. Monad m => a -> m a
return()elseforall a. String -> String -> a
die String
"fromListN"String
"list length less than specified size"go !Int
ix (a
x :[a]
xs )=ifInt
ix forall a. Ord a => a -> a -> Bool
<Int
n thendoforall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s a
sma Int
ix a
x Int -> [a] -> ST s ()
go (Int
ix forall a. Num a => a -> a -> a
+Int
1)[a]
xs elseforall a. String -> String -> a
die String
"fromListN"String
"list length greater than specified size"inInt -> [a] -> ST s ()
go Int
0[a]
l -- | Create an array from a list.arrayFromList ::[a ]->Array a arrayFromList :: forall a. [a] -> Array a
arrayFromList [a]
l =forall a. Int -> [a] -> Array a
arrayFromListN (forall (t :: * -> *) a. Foldable t => t a -> Int
length[a]
l )[a]
l instanceExts.IsList(Array a )wheretypeItem(Array a )=a fromListN :: Int -> [Item (Array a)] -> Array a
fromListN=forall a. Int -> [a] -> Array a
arrayFromListN fromList :: [Item (Array a)] -> Array a
fromList=forall a. [a] -> Array a
arrayFromList toList :: Array a -> [Item (Array a)]
toList=forall (t :: * -> *) a. Foldable t => t a -> [a]
toListinstanceFunctorArray wherefmap :: forall a b. (a -> b) -> Array a -> Array b
fmapa -> b
f Array a
a =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (forall a. Array a -> Int
sizeofArray Array a
a )(forall a. String -> String -> a
die String
"fmap"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s b
mb ->letgo :: Int -> ST s ()
go Int
i |Int
i forall a. Eq a => a -> a -> Bool
==forall a. Array a -> Int
sizeofArray Array a
a =forall (m :: * -> *) a. Monad m => a -> m a
return()|Bool
otherwise=doa
x <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
a Int
i forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s b
mb Int
i (a -> b
f a
x )forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)inInt -> ST s ()
go Int
0a
e <$ :: forall a b. a -> Array b -> Array a
<$Array b
a =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (forall a. Array a -> Int
sizeofArray Array b
a )a
e (\!MutableArray s a
_->forall (f :: * -> *) a. Applicative f => a -> f a
pure())instanceApplicativeArray wherepure :: forall a. a -> Array a
purea
x =forall a. (forall s. ST s (MutableArray s a)) -> Array a
runArray forall a b. (a -> b) -> a -> b
$forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
1a
x Array (a -> b)
ab <*> :: forall a b. Array (a -> b) -> Array a -> Array b
<*>Array a
a =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (Int
szab forall a. Num a => a -> a -> a
*Int
sza )(forall a. String -> String -> a
die String
"<*>"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s b
mb ->letgo1 :: Int -> ST s ()
go1 Int
i =forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when(Int
i forall a. Ord a => a -> a -> Bool
<Int
szab )forall a b. (a -> b) -> a -> b
$doa -> b
f <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array (a -> b)
ab Int
i Int -> (a -> b) -> Int -> ST s ()
go2 (Int
i forall a. Num a => a -> a -> a
*Int
sza )a -> b
f Int
0Int -> ST s ()
go1 (Int
i forall a. Num a => a -> a -> a
+Int
1)go2 :: Int -> (a -> b) -> Int -> ST s ()
go2 Int
off a -> b
f Int
j =forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when(Int
j forall a. Ord a => a -> a -> Bool
<Int
sza )forall a b. (a -> b) -> a -> b
$doa
x <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
a Int
j forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s b
mb (Int
off forall a. Num a => a -> a -> a
+Int
j )(a -> b
f a
x )Int -> (a -> b) -> Int -> ST s ()
go2 Int
off a -> b
f (Int
j forall a. Num a => a -> a -> a
+Int
1)inInt -> ST s ()
go1 Int
0whereszab :: Int
szab =forall a. Array a -> Int
sizeofArray Array (a -> b)
ab ;sza :: Int
sza =forall a. Array a -> Int
sizeofArray Array a
a Array a
a *> :: forall a b. Array a -> Array b -> Array b
*>Array b
b =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (Int
sza forall a. Num a => a -> a -> a
*Int
szb )(forall a. String -> String -> a
die String
"*>"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s b
mb ->letgo :: Int -> ST s ()
go Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
sza =forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray MutableArray s b
mb (Int
i forall a. Num a => a -> a -> a
*Int
szb )Array b
b Int
0Int
szb forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)|Bool
otherwise=forall (m :: * -> *) a. Monad m => a -> m a
return()inInt -> ST s ()
go Int
0wheresza :: Int
sza =forall a. Array a -> Int
sizeofArray Array a
a ;szb :: Int
szb =forall a. Array a -> Int
sizeofArray Array b
b Array a
a <* :: forall a b. Array a -> Array b -> Array a
<*Array b
b =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (Int
sza forall a. Num a => a -> a -> a
*Int
szb )(forall a. String -> String -> a
die String
"<*"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s a
ma ->letfill :: Int -> Int -> a -> ST s ()
fill Int
off Int
i a
e |Int
i forall a. Ord a => a -> a -> Bool
<Int
szb =forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s a
ma (Int
off forall a. Num a => a -> a -> a
+Int
i )a
e forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>Int -> Int -> a -> ST s ()
fill Int
off (Int
i forall a. Num a => a -> a -> a
+Int
1)a
e |Bool
otherwise=forall (m :: * -> *) a. Monad m => a -> m a
return()go :: Int -> ST s ()
go Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
sza =doa
x <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
a Int
i Int -> Int -> a -> ST s ()
fill (Int
i forall a. Num a => a -> a -> a
*Int
szb )Int
0a
x forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)|Bool
otherwise=forall (m :: * -> *) a. Monad m => a -> m a
return()inInt -> ST s ()
go Int
0wheresza :: Int
sza =forall a. Array a -> Int
sizeofArray Array a
a ;szb :: Int
szb =forall a. Array a -> Int
sizeofArray Array b
b instanceAlternativeArray whereempty :: forall a. Array a
empty=forall a. Array a
emptyArray Array a
a1 <|> :: forall a. Array a -> Array a -> Array a
<|>Array a
a2 =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (Int
sza1 forall a. Num a => a -> a -> a
+Int
sza2 )(forall a. String -> String -> a
die String
"<|>"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s a
ma ->forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray MutableArray s a
ma Int
0Array a
a1 Int
0Int
sza1 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray MutableArray s a
ma Int
sza1 Array a
a2 Int
0Int
sza2 wheresza1 :: Int
sza1 =forall a. Array a -> Int
sizeofArray Array a
a1 ;sza2 :: Int
sza2 =forall a. Array a -> Int
sizeofArray Array a
a2 some :: forall a. Array a -> Array [a]
someArray a
a |forall a. Array a -> Int
sizeofArray Array a
a forall a. Eq a => a -> a -> Bool
==Int
0=forall a. Array a
emptyArray |Bool
otherwise=forall a. String -> String -> a
die String
"some"String
"infinite arrays are not well defined"many :: forall a. Array a -> Array [a]
manyArray a
a |forall a. Array a -> Int
sizeofArray Array a
a forall a. Eq a => a -> a -> Bool
==Int
0=forall (f :: * -> *) a. Applicative f => a -> f a
pure[]|Bool
otherwise=forall a. String -> String -> a
die String
"many"String
"infinite arrays are not well defined"dataArrayStack a =PushArray !(Array a )!(ArrayStack a )|EmptyStack -- See the note in SmallArray about how we might improve this.instanceMonadArray wherereturn :: forall a. a -> Array a
return=forall (f :: * -> *) a. Applicative f => a -> f a
pure>> :: forall a b. Array a -> Array b -> Array b
(>>)=forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)Array a
ary >>= :: forall a b. Array a -> (a -> Array b) -> Array b
>>=a -> Array b
f =Int -> ArrayStack b -> Int -> Array b
collect Int
0forall a. ArrayStack a
EmptyStack (Int
la forall a. Num a => a -> a -> a
-Int
1)wherela :: Int
la =forall a. Array a -> Int
sizeofArray Array a
ary collect :: Int -> ArrayStack b -> Int -> Array b
collect Int
sz ArrayStack b
stk Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
0=forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray Int
sz (forall a. String -> String -> a
die String
">>="String
"impossible")forall a b. (a -> b) -> a -> b
$forall {m :: * -> *} {a}.
PrimMonad m =>
Int -> ArrayStack a -> MutableArray (PrimState m) a -> m ()
fill Int
0ArrayStack b
stk |(#a
x #)<-forall a. Array a -> Int -> (# a #)
indexArray## Array a
ary Int
i ,letsb :: Array b
sb =a -> Array b
f a
x lsb :: Int
lsb =forall a. Array a -> Int
sizeofArray Array b
sb -- If we don't perform this check, we could end up allocating-- a stack full of empty arrays if someone is filtering most-- things out. So we refrain from pushing empty arrays.=ifInt
lsb forall a. Eq a => a -> a -> Bool
==Int
0thenInt -> ArrayStack b -> Int -> Array b
collect Int
sz ArrayStack b
stk (Int
i forall a. Num a => a -> a -> a
-Int
1)elseInt -> ArrayStack b -> Int -> Array b
collect (Int
sz forall a. Num a => a -> a -> a
+Int
lsb )(forall a. Array a -> ArrayStack a -> ArrayStack a
PushArray Array b
sb ArrayStack b
stk )(Int
i forall a. Num a => a -> a -> a
-Int
1)fill :: Int -> ArrayStack a -> MutableArray (PrimState m) a -> m ()
fill Int
_ArrayStack a
EmptyStack MutableArray (PrimState m) a
_=forall (m :: * -> *) a. Monad m => a -> m a
return()fill Int
off (PushArray Array a
sb ArrayStack a
sbs )MutableArray (PrimState m) a
smb |letlsb :: Int
lsb =forall a. Array a -> Int
sizeofArray Array a
sb =forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray MutableArray (PrimState m) a
smb Int
off Array a
sb Int
0Int
lsb forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>Int -> ArrayStack a -> MutableArray (PrimState m) a -> m ()
fill (Int
off forall a. Num a => a -> a -> a
+Int
lsb )ArrayStack a
sbs MutableArray (PrimState m) a
smb 
#if !(MIN_VERSION_base(4,13,0))
fail=Fail.fail
#endif
instanceFail.MonadFailArray wherefail :: forall a. String -> Array a
failString
_=forall (f :: * -> *) a. Alternative f => f a
emptyinstanceMonadPlusArray wheremzero :: forall a. Array a
mzero=forall (f :: * -> *) a. Alternative f => f a
emptymplus :: forall a. Array a -> Array a -> Array a
mplus=forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)zipW ::String->(a ->b ->c )->Array a ->Array b ->Array c zipW :: forall a b c.
String -> (a -> b -> c) -> Array a -> Array b -> Array c
zipW String
s a -> b -> c
f Array a
aa Array b
ab =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray Int
mn (forall a. String -> String -> a
die String
s String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s c
mc ->letgo :: Int -> ST s ()
go Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
mn =doa
x <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array a
aa Int
i b
y <-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array b
ab Int
i forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s c
mc Int
i (a -> b -> c
f a
x b
y )Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)|Bool
otherwise=forall (m :: * -> *) a. Monad m => a -> m a
return()inInt -> ST s ()
go Int
0wheremn :: Int
mn =forall a. Array a -> Int
sizeofArray Array a
aa forall a. Ord a => a -> a -> a
`min`forall a. Array a -> Int
sizeofArray Array b
ab {-# INLINEzipW #-}instanceMonadZipArray wheremzip :: forall a b. Array a -> Array b -> Array (a, b)
mzipArray a
aa Array b
ab =forall a b c.
String -> (a -> b -> c) -> Array a -> Array b -> Array c
zipW String
"mzip"(,)Array a
aa Array b
ab mzipWith :: forall a b c. (a -> b -> c) -> Array a -> Array b -> Array c
mzipWitha -> b -> c
f Array a
aa Array b
ab =forall a b c.
String -> (a -> b -> c) -> Array a -> Array b -> Array c
zipW String
"mzipWith"a -> b -> c
f Array a
aa Array b
ab munzip :: forall a b. Array (a, b) -> (Array a, Array b)
munzipArray (a, b)
aab =forall a. (forall s. ST s a) -> a
runSTforall a b. (a -> b) -> a -> b
$doletsz :: Int
sz =forall a. Array a -> Int
sizeofArray Array (a, b)
aab MutableArray s a
ma <-forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
sz (forall a. String -> String -> a
die String
"munzip"String
"impossible")MutableArray s b
mb <-forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
sz (forall a. String -> String -> a
die String
"munzip"String
"impossible")letgo :: Int -> ST s ()
go Int
i |Int
i forall a. Ord a => a -> a -> Bool
<Int
sz =do(a
a ,b
b )<-forall (m :: * -> *) a. Monad m => Array a -> Int -> m a
indexArrayM Array (a, b)
aab Int
i forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s a
ma Int
i a
a forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s b
mb Int
i b
b Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)go Int
_=forall (m :: * -> *) a. Monad m => a -> m a
return()Int -> ST s ()
go Int
0(,)forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray MutableArray s a
ma forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray MutableArray s b
mb instanceMonadFixArray wheremfix :: forall a. (a -> Array a) -> Array a
mfixa -> Array a
f =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (forall a. Array a -> Int
sizeofArray (a -> Array a
f forall a. a
err ))(forall a. String -> String -> a
die String
"mfix"String
"impossible")forall a b. (a -> b) -> a -> b
$forall a b c. (a -> b -> c) -> b -> a -> c
flipforall a. (a -> a) -> a
fixInt
0forall a b. (a -> b) -> a -> b
$\Int -> MutableArray s a -> ST s ()
r !Int
i !MutableArray s a
mary ->forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when(Int
i forall a. Ord a => a -> a -> Bool
<Int
sz )forall a b. (a -> b) -> a -> b
$doforall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray s a
mary Int
i (forall a. (a -> a) -> a
fix(\a
xi ->a -> Array a
f a
xi forall a. Array a -> Int -> a
`indexArray` Int
i ))Int -> MutableArray s a -> ST s ()
r (Int
i forall a. Num a => a -> a -> a
+Int
1)MutableArray s a
mary wheresz :: Int
sz =forall a. Array a -> Int
sizeofArray (a -> Array a
f forall a. a
err )err :: a
err =forall a. HasCallStack => String -> a
errorString
"mfix for Data.Primitive.Array applied to strict function."-- | @since 0.6.3.0instanceSemigroup(Array a )where<> :: Array a -> Array a -> Array a
(<>)=forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)sconcat :: NonEmpty (Array a) -> Array a
sconcat=forall a. Monoid a => [a] -> a
mconcatforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toListstimes :: forall b. Integral b => b -> Array a -> Array a
stimesb
n Array a
arr =caseforall a. Ord a => a -> a -> Ordering
compareb
n b
0ofOrdering
LT->forall a. String -> String -> a
die String
"stimes"String
"negative multiplier"Ordering
EQ->forall (f :: * -> *) a. Alternative f => f a
emptyOrdering
GT->forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray (Int
n' forall a. Num a => a -> a -> a
*forall a. Array a -> Int
sizeofArray Array a
arr )(forall a. String -> String -> a
die String
"stimes"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s a
ma ->letgo :: Int -> ST s ()
go Int
i =ifInt
i forall a. Ord a => a -> a -> Bool
<Int
n' thendoforall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray MutableArray s a
ma (Int
i forall a. Num a => a -> a -> a
*forall a. Array a -> Int
sizeofArray Array a
arr )Array a
arr Int
0(forall a. Array a -> Int
sizeofArray Array a
arr )Int -> ST s ()
go (Int
i forall a. Num a => a -> a -> a
+Int
1)elseforall (m :: * -> *) a. Monad m => a -> m a
return()inInt -> ST s ()
go Int
0wheren' :: Int
n' =forall a b. (Integral a, Num b) => a -> b
fromIntegralb
n ::IntinstanceMonoid(Array a )wheremempty :: Array a
mempty=forall (f :: * -> *) a. Alternative f => f a
empty
#if !(MIN_VERSION_base(4,11,0))
mappend=(<>)
#endif
mconcat :: [Array a] -> Array a
mconcat[Array a]
l =forall a.
Int -> a -> (forall s. MutableArray s a -> ST s ()) -> Array a
createArray Int
sz (forall a. String -> String -> a
die String
"mconcat"String
"impossible")forall a b. (a -> b) -> a -> b
$\MutableArray s a
ma ->letgo :: Int -> [Array a] -> ST s ()
go !Int
_[]=forall (m :: * -> *) a. Monad m => a -> m a
return()go Int
off (Array a
a :[Array a]
as )=forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray MutableArray s a
ma Int
off Array a
a Int
0(forall a. Array a -> Int
sizeofArray Array a
a )forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>Int -> [Array a] -> ST s ()
go (Int
off forall a. Num a => a -> a -> a
+forall a. Array a -> Int
sizeofArray Array a
a )[Array a]
as inInt -> [Array a] -> ST s ()
go Int
0[Array a]
l wheresz :: Int
sz =forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sumforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmapforall a. Array a -> Int
sizeofArray forall a b. (a -> b) -> a -> b
$[Array a]
l arrayLiftShowsPrec ::(Int->a ->ShowS)->([a ]->ShowS)->Int->Array a ->ShowSarrayLiftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Array a -> ShowS
arrayLiftShowsPrec Int -> a -> ShowS
elemShowsPrec [a] -> ShowS
elemListShowsPrec Int
p Array a
a =Bool -> ShowS -> ShowS
showParen(Int
p forall a. Ord a => a -> a -> Bool
>Int
10)forall a b. (a -> b) -> a -> b
$String -> ShowS
showStringString
"fromListN "forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a. Show a => a -> ShowS
shows(forall a. Array a -> Int
sizeofArray Array a
a )forall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> ShowS
showStringString
" "forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> [a] -> ShowS
listLiftShowsPrec Int -> a -> ShowS
elemShowsPrec [a] -> ShowS
elemListShowsPrec Int
11(forall (t :: * -> *) a. Foldable t => t a -> [a]
toListArray a
a )-- this need to be included for older ghcslistLiftShowsPrec ::(Int->a ->ShowS)->([a ]->ShowS)->Int->[a ]->ShowSlistLiftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> [a] -> ShowS
listLiftShowsPrec Int -> a -> ShowS
_[a] -> ShowS
sl Int
_=[a] -> ShowS
sl instanceShowa =>Show(Array a )whereshowsPrec :: Int -> Array a -> ShowS
showsPrecInt
p Array a
a =forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Array a -> ShowS
arrayLiftShowsPrec forall a. Show a => Int -> a -> ShowS
showsPrecforall a. Show a => [a] -> ShowS
showListInt
p Array a
a -- | @since 0.6.4.0instanceShow1Array whereliftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Array a -> ShowS
liftShowsPrec=forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Array a -> ShowS
arrayLiftShowsPrec instanceReada =>Read(Array a )wherereadPrec :: ReadPrec (Array a)
readPrec=forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (Array a)
arrayLiftReadPrec forall a. Read a => ReadPrec a
readPrecforall a. Read a => ReadPrec [a]
readListPrec-- | @since 0.6.4.0instanceRead1Array where
#if MIN_VERSION_base(4,10,0)
liftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (Array a)
liftReadPrec=forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (Array a)
arrayLiftReadPrec 
#else
liftReadsPrec=arrayLiftReadsPrec
#endif
-- We're really forgiving here. We accept-- "[1,2,3]", "fromList [1,2,3]", and "fromListN 3 [1,2,3]".-- We consider fromListN with an invalid length to be an-- error, rather than a parse failure, because doing otherwise-- seems weird and likely to make debugging difficult.arrayLiftReadPrec ::ReadPreca ->ReadPrec[a ]->ReadPrec(Array a )arrayLiftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (Array a)
arrayLiftReadPrec ReadPrec a
_ReadPrec [a]
read_list =forall a. ReadPrec a -> ReadPrec a
parensforall a b. (a -> b) -> a -> b
$forall a. Int -> ReadPrec a -> ReadPrec a
precInt
app_prec forall a b. (a -> b) -> a -> b
$forall a. ReadP a -> ReadPrec a
RdPrc.liftReadP ()
skipSpacesforall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>((forall l. IsList l => [Item l] -> l
fromListforall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>ReadPrec [a]
read_list )forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
RdPrc.+++doTag
tag <-forall a. ReadP a -> ReadPrec a
RdPrc.liftReadP Tag
lexTag caseTag
tag ofTag
FromListTag ->forall l. IsList l => [Item l] -> l
fromListforall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>ReadPrec [a]
read_list Tag
FromListNTag ->forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2forall l. IsList l => Int -> [Item l] -> l
fromListNforall a. Read a => ReadPrec a
readPrecReadPrec [a]
read_list )whereapp_prec :: Int
app_prec =Int
10dataTag =FromListTag |FromListNTag -- Why don't we just use lexP? The general problem with lexP is that-- it doesn't always fail as fast as we might like. It will-- happily read to the end of an absurdly long lexeme (e.g., a 200MB string-- literal) before returning, at which point we'll immediately discard-- the result because it's not an identifier. Doing the job ourselves, we-- can see very quickly when we've run into a problem. We should also get-- a slight efficiency boost by going through the string just once.lexTag ::ReadPTag lexTag :: ReadP Tag
lexTag =doString
_<-String -> ReadP String
stringString
"fromList"String
s <-ReadP String
lookcaseString
s ofChar
'N':Char
c :String
_|Char
'0'forall a. Ord a => a -> a -> Bool
<=Char
c Bool -> Bool -> Bool
&&Char
c forall a. Ord a => a -> a -> Bool
<=Char
'9'->forall (m :: * -> *) a. MonadFail m => String -> m a
failString
""-- We have fromListN3 or similar|Bool
otherwise->Tag
FromListNTag forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ReadP Char
get-- Skip the 'N'String
_->forall (m :: * -> *) a. Monad m => a -> m a
returnTag
FromListTag 
#if !MIN_VERSION_base(4,10,0)
arrayLiftReadsPrec::(Int->ReadSa)->ReadS[a]->Int->ReadS(Arraya)arrayLiftReadsPrecreads_preclist_reads_prec=RdPrc.readPrec_to_S$arrayLiftReadPrec(RdPrc.readS_to_Precreads_prec)(RdPrc.readS_to_Prec(constlist_reads_prec))
#endif
arrayDataType ::DataTypearrayDataType :: DataType
arrayDataType =String -> [Constr] -> DataType
mkDataTypeString
"Data.Primitive.Array.Array"[Constr
fromListConstr ]fromListConstr ::ConstrfromListConstr :: Constr
fromListConstr =DataType -> String -> [String] -> Fixity -> Constr
mkConstrDataType
arrayDataType String
"fromList"[]Fixity
PrefixinstanceDataa =>Data(Array a )wheretoConstr :: Array a -> Constr
toConstrArray a
_=Constr
fromListConstr dataTypeOf :: Array a -> DataType
dataTypeOfArray a
_=DataType
arrayDataType gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Array a)
gunfoldforall b r. Data b => c (b -> r) -> c r
k forall r. r -> c r
z Constr
c =caseConstr -> Int
constrIndexConstr
c ofInt
1->forall b r. Data b => c (b -> r) -> c r
k (forall r. r -> c r
z forall l. IsList l => [Item l] -> l
fromList)Int
_->forall a. HasCallStack => String -> a
errorString
"gunfold"gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Array a -> c (Array a)
gfoldlforall d b. Data d => c (d -> b) -> d -> c b
f forall g. g -> c g
z Array a
m =forall g. g -> c g
z forall l. IsList l => [Item l] -> l
fromListforall d b. Data d => c (d -> b) -> d -> c b
`f` forall (t :: * -> *) a. Foldable t => t a -> [a]
toListArray a
m instance(Typeables ,Typeablea )=>Data(MutableArray s a )wheretoConstr :: MutableArray s a -> Constr
toConstr MutableArray s a
_=forall a. HasCallStack => String -> a
errorString
"toConstr"gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MutableArray s a)
gunfold forall b r. Data b => c (b -> r) -> c r
_forall r. r -> c r
_=forall a. HasCallStack => String -> a
errorString
"gunfold"dataTypeOf :: MutableArray s a -> DataType
dataTypeOf MutableArray s a
_=String -> DataType
mkNoRepTypeString
"Data.Primitive.Array.MutableArray"