{-#LANGUAGE不安全#-}
｛-#LANGUAGE NoImplicitFlave、MagicHash、UnboxedCouples、RoleAnnotations#-｝语言
｛-#语言BangPatterns#-｝
{-#OPTIONS_HADDOCK非本地#-}

-----------------------------------------------------------------------------
-- |
--模块：GHC。Arr公司
--版权所有：（c）格拉斯哥大学，1994-2000
--许可证：请参阅库/基础/许可证
--
--维护人员：cvs-ghc@haskell.org
--稳定性：内部
--便携性：非便携（GHC扩展）
--
--GHC的阵列实现。
--
-----------------------------------------------------------------------------

模块 全球总部。Arr公司 (
        Ix公司(..), 阵列(..), STArray公司(..),

        arrEle底部, 阵列, listArray（列表数组）,
        (!), 安全范围大小, 负范围, 安全索引, 错误安全索引,
        边界, num个元素, num元素STArray, 指数, 元素,
        美国海军陆战队, accumArray（累计阵列）, 调整, (//), 累计,
        阿玛普, ixmap地图,
        eqArray（eq阵列）, cmpArray（cmp阵列）, cmpIntArray（cmpInt阵列）,
        newSTArray（新STArray）, boundsSTArray公司,
        readSTArray（readSTArray）, 写入STArray,
        冷冻STArray, thawSTArray（thawSTA阵列）,
        foldlElems（折叠元素）, foldlElems的, fold1项目,
        foldrElems（文件夹元素）, foldrElems的, foldr1项目,

        --*不安全操作
        填满, 完成,
        unsafeArray（不安全阵列）, unsafeArray“,
        不安全指数, 不安全状态, 不安全替换,
        unsafeAccumArray（不安全累计阵列）, unsafeAccumArray’, 不安全累计,
        不安全的ReadSTArray, 不安全的WriteSTArray,
        不安全FreezeSTArray, 不安全的解冻,
    ) 哪里

进口 全球总部。号码
进口 全球总部。标准时间
进口 全球总部。底座
进口 全球总部。列表
进口 GHC。Ix公司
进口 全球总部。显示

中缀 9  !, //

违约 ()

--|不可变非限定（装箱）数组的类型
--索引在@i@中，元素在@e@中。
数据 阵列 我 e（电子）
   = 阵列            !我         --下限，l
                      !我         --上限u
       {-#解压缩 #-} !国际       --缓存（rangeSize（l，u））
                                 --用于确保索引
                                 --确实在范围内
                      (阵列# e（电子）) --实际元素

--|“ST”monad中的可变、装箱、非严格数组。类型
--参数如下：
--
--*@s@：“ST”类型的状态变量参数
--
--*@i@：数组的索引类型（应该是“Ix”的实例）
--
--*@e@：数组的元素类型。
--
数据 STArray公司 秒 我 e（电子）
  = STArray公司           !我               --下限，l
                      !我               --上限u
      {-#解压缩 #-}  !国际             --缓存（rangeSize（l，u））
                                       --用于确保索引
                                       --确实在范围内
                   (可变数组# 秒 e（电子）) --实际元素
        --STArray没有Ix上下文。他们很愚蠢，
        --并在相等实例上强制使用Ix上下文。

--由于Ix类，索引类型应该具有标称角色。另请参见#9220。
类型 角色 阵列 名义上的 代表性的
类型 角色 STArray公司 名义上的 名义上的 代表性的

--可变数组上的指针相等：
--自2.01起|@
实例 等式 (STArray公司 秒 我 e（电子）) 哪里
    STArray公司 我_ 我_ 国际_ 可变数组#s earr1型# ==：：STArray si e->STArray s i e->Bool== STArray公司 我_ 我_ 国际_ 可变阵列#s earr2型# =
        Int#->布尔为True# (MutableArray#s e->MutableArray#s e->Int#对于所有d a.MutableArray#d a->MutableArray#d a->Int#sameMutableArray（相同可变阵列）# 可变数组#s earr1型# 可变数组#s e棱2#)

----------------------------------------------------------------------
--对不可变数组的操作

{-#无线 arrEle底部 #-}
arrEle底部 时间： 一
arrEleBottom:：aarrEle底部 = [Char]->a（字符）对于所有a.[Char]->a错误没有堆栈跟踪 [字符]“（Array.！）：未定义的数组元素”

--|构造一个具有指定边界并包含值的数组
--对于这些边界内的给定索引。
--
--如果列表中的任何索引为
--越界。哈斯克尔2010年报告进一步规定，如果有
--列表中的两个关联具有相同的索引，其值为
--索引未定义（即底部）。然而，在GHC的实施中，
--这样一个索引的值是最后一个关联的值部分
--列表中包含该索引。
--
--因为必须检查索引中的这些错误，所以“array”是
--严格限制参数和关联索引
--列表，但在值中不受限制。因此，类似
--以下是可能的：
--
-->a=数组（1100）（（1,1）：[（i，i*a！（i-1））|i<-[2..100]]）
--
--不是数组边界内的每个索引都需要出现在
--关联列表，但与不
--显示将是未定义的（即底部）。
--
--如果在任何维度中，下限大于上限，
--那么数组是合法的，但是空的。始终为空数组编制索引
--给出数组边界错误，但“边界”仍会产生边界
--用来构造数组的。
{-#内联 阵列 #-}
阵列 时间： Ix公司 我
        => (我,我)        --^一对/边界/，每个索引类型
                        --数组的。这些界限是最低的
                        --按此顺序排列数组中的最高索引。
                        --例如，长度的单原点向量
                        --@10@有边界@（1,10）@，一个原点@10@
                        --通过@10@矩阵有界@（（1,1），（10,10））@。
        -> [(我, e（电子）)]     --^表格的/协会/列表
                        --（/index/，/value/）。通常，此列表将
                        --表达为理解。安
                        --关联@（i，x）@定义
                        --索引@i@处的数组为@x@。
        -> 阵列 我 e（电子）
数组：：（i，i）->[（i，e）]->数组ie阵列 (我我,我u个) [（i，e）]是
    = 让 n：：整数n个 = （i，i）->国际对于所有i.Ix i=>（i，i）->Int安全范围大小 (我我,我u个)
      在里面 （i，i）->Int->[（Int，e）]->数组i e对于所有（i，i）->Int->[（Int，e）]->数组i eunsafeArray“ (我我,我u个) 国际n个
                      [(（i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我, e（电子）e（电子）) | (我我, e（电子）e（电子）) <- [（i，e）]是]

｛-#内联 unsafeArray（非安全阵列） #-}
unsafeArray（不安全阵列） 时间： Ix公司 我 => (我,我) -> [(国际, e（电子）)] -> 阵列 我 e（电子）
unsafeArray:：（i，i）->[（Int，e）]->数组i eunsafeArray（不安全阵列） （i，i）b条 [（国际）]是 = （i，i）->Int->[（Int，e）]->数组i e对于所有（i，i）->Int->[（Int，e）]->数组i eunsafeArray“ （i，i）b条 (（i，i）->国际对于所有i.Ix i=>（i，i）->Int范围大小 （i，i）b条) [（国际）]是

{-#内联 unsafeArray“ #-}
unsafeArray“ 时间： (我,我) -> 国际 -> [(国际, e（电子）)] -> 阵列 我 e（电子）
unsafeArray’：：（i，i）->Int->[（Int，e）]->数组ieunsafeArray“ (我我,我u个) n：：整数n个@(我# 国际#n个#) [（国际）]是 = （对于所有s.ST（阵列））->阵列对于所有a.（对于所有s.ST s a）->a运行ST (STRep s（阵列i e）->ST s（阵列e）对于所有s.STRip s a->ST s a标准时间 （STRep s（阵列i e）->ST s（阵列e））->STRep s（阵列i e）->ST s（阵列e）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 Int#->e->状态#s->（#状态#s，可变数组#s e#）对于所有a d。Int#->a->状态#d->（#状态#d，可变数组#d a#）newArray（新阵列）# 国际#n个# e（电子）对于所有a.aarrEle底部 州#第1页# 属于
        (# 州#s2秒#, 可变数组#s e马尔# #) ->
            （（（Int，e）->STRep s（数组i e）->STRep s（数组e））->STRep s（数组i e）->[（Int，e）]->STReps（数组e）对于所有a b（a->b->b）->b->[a]->b文件夹 (可变数组#s e->（Int，e）->STRep s（数组ie）->STRep s（数组ue）对于所有人来说。MutableArray#s e->（Int，e）->STRep s a->STReps s a填满 可变数组#s e马尔#) (i->i->Int->MutableArray#s e->STRep s（数组i e）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 可变数组#s e马尔#) [（国际）]是 州#s2秒#)

{-#内联 填满 #-}
填满 时间： 可变数组# 秒 e（电子） -> (国际, e（电子）) -> STRep公司 秒 一 -> ST代表 秒 一
--注意：将\s放在“=”之后，以便“填充”
--应用于三个参数时内联
fill:：MutableArray#s e->（Int，e）->STRep s a->STRep s a填满 可变数组#s e马尔# (我# 国际#我#, e（电子）e（电子）) STRip s结构下一个
 = \州#第1页# -> 案例 MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# e（电子）e（电子） 州#第1页# 属于
             州#s2秒# -> STRip s结构下一个 州#第2页#

{-#内联 完成 #-}
完成 时间： 我 -> 我 -> 国际 -> 可变数组# 秒 e（电子） -> STRep公司 秒 (阵列 我 e（电子）)
--见注“填充”
--确保在“n”中严格
完成：：i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 n：：整数n个@(我# 国际#_) 可变数组#s e马尔#
  = \状态#ss1# -> 案例 可变数组#s e->状态#s->（#状态#s，数组#e#）对于所有数据a。可变数组#d a->状态#d->（#状态#d，数组#a#）unsafeFreezeArray# 可变数组#s e马尔# 州#第1页# 属于
              (# 州#s2秒#, 数组#e阿珥# #) -> (# 州#s2秒#, i->i->Int->数组#e->数组ie例如，i->i->Int->Array#e->Array i e阵列 我我 我u个 国际n个 数组#e阿珥# #)

--|从中的一对边界和值列表构造数组
--索引顺序。
{-#内联 listArray（列表数组） #-}
listArray（列表数组） 时间： Ix公司 我 => (我,我) -> [e（电子）] -> 阵列 我 e（电子）
listArray：：（i，i）->[e]->数组ielistArray（列表数组） (我我,我u个) [英]锿 = （对于所有s.ST（阵列））->阵列对于所有a.（对于所有s.ST s a）->a运行ST (STRep s（阵列i e）->ST s（阵列e）对于所有s.STRip s a->ST s a标准时间 （STRep s（阵列i e）->ST s（阵列e））->STRep s（阵列i e）->ST s（阵列e）对于所有a b（a->b）->a->b$ \状态#ss1# ->
    案例 （i，i）->国际对于所有i.Ix i=>（i，i）->Int安全范围大小 (我我,我u个)            属于 { n：：整数n个@(我# 国际#n个#) ->
    案例 Int#->e->状态#s->（#状态#s，MutableArray#s e#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）newArray（新阵列）# 国际#n个# e（电子）对于所有a.aarrEle底部 州#第1页#  属于 { (# 州#s2秒#, 可变数组#s e马尔# #) ->
      让
        go:：e->（Int#->State#s->State#s）->Int#->State#s->State#s去 e（电子）年 Int#->状态#s->状态#s第页 = \ 国际#我# 州#第3节# ->
            案例 MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# e（电子）年 状态#s第3页# 属于
              州#第4节# -> 如果 (Int#->布尔为True# (国际#我# Int#->Int#->内部#==# 国际#n个# Int#->Int#->内部#-# 国际#1#))
                     然后 州#第4节#
                     其他的 Int#->状态#s->状态#s第页 (国际#我# Int#->Int#->内部#+# 国际#1#) 状态#s第4节#
      在里面
        i->i->Int->MutableArray#s e->STRep s（数组i e）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 可变数组#s e马尔# (
          如果 国际n个 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0
          然后 州#s2秒#
          其他的 （e）->（Int#->状态#s->状态#s）->Int#->状态#s->State#s）->（Int#->状态#s->状态#s）->[电子]->国际#->州#->州#对于所有a b（a->b->b）->b->[a]->b文件夹 e->（Int#->状态#s->状态#s）->Int#->状态#s->State#s去 (\国际#_ 州#秒# -> 州#秒#) [英]锿 国际#0# 州#s2秒#)}})

--|数组中给定索引处的值。
{-#内联 (!) #-}
(!) 时间： Ix公司 我 => 阵列 我 e（电子） -> 我 -> e（电子）
(!) arr:：数组阿珥@(阵列 我我 我u个 国际n个 数组#e_) 我我 = 数组e->Int->e对于所有阵列->Int->e不安全状态 阵列i e阿珥 （国际->e）->国际->e对于所有a b（a->b）->a->b$ （i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我

{-#内联 (!#) #-}
(!#) 时间： Ix公司 我 => 阵列 我 e（电子） -> 我 -> (# e（电子） #)
!# :: 数组i e->i->（#e#）（！#） arr:：数组i e阿珥@(阵列 我我 我u个 国际n个 数组#e_) 我我 = 数组e->Int->（#e#）对于所有阵列->Int->（#e#）不安全状态# 阵列i e阿珥 （整数->（#e#））->整数->（#e#）对于所有a b（a->b）->a->b$ （i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我

{-#内联 安全范围大小 #-}
安全范围大小 时间： Ix公司 我 => (我, 我) -> 国际
安全范围大小：：（i，i）->Int安全范围大小 (我我,我u个) = 让 r：：整数第页 = （i，i）->国际对于所有i.Ix i=>（i，i）->Int范围大小 (我我, 我u个)
                      在里面 如果 国际第页 国际->国际->布尔对于所有a.订单a=>a->a->Bool< 国际0 然后 国际负范围
                                  其他的 国际第页

--不要到处内联此错误消息！！
负范围 时间： 国际   --非信息性，但Ix不提供Show
负范围：：Int负范围 = [Char]->国际对于所有a.[Char]->a错误没有堆栈跟踪 [字符]“负范围大小”

{-#内联[1] 安全索引 #-}
--请参见注释[索引值的双边界检查]
--在*（！）之后内联*，以便规则可以启动
--确保n中严格
安全索引 时间： Ix公司 我 => (我, 我) -> 国际 -> 我 -> 国际
安全索引：：（i，i）->Int->i->Int安全索引 (我我,我u个) n：：整数n个@(我# 国际#_) 我我
  | (国际0 国际->国际->布尔对于所有a.订单a=>a->a->Bool<= 国际我') 布尔->布尔->布尔&& (国际我' 国际->国际->布尔对于所有a.订单a=>a->a->Bool< 国际n个) = 国际我'
  | 布尔否则             = 国际->国际->国际错误安全索引 国际我' 国际n个
  哪里
    i'：：整数我' = （i，i）->i->Int对于所有a.Ix a=>（a，a）->a->Int指数 (我我,我u个) 我我

--参见注释[指数值的双边界检查]
｛-#规则
“安全索引/I”       安全索引 = 不安全指数 时间： (国际,国际) -> 国际 -> 国际 -> 国际
“安全索引/（I，I）”   安全索引 = 不安全指数 时间： ((国际,国际),(国际,国际)) -> 国际 -> (国际,国际) -> 国际
“安全索引/（I，I，I）” 安全索引 = 不安全指数 时间： ((国际,国际,国际),(国际,国际,国际)) -> 国际 -> (国际,国际,国际) -> 国际
  #-}

不安全指数 时间： Ix公司 我 => (我, 我) -> 国际 -> 我 -> 国际
--参见注释[指数值的双边界检查]
--只做（A），语义检查
lessSafeIndex:：（i，i）->Int->i->Int不安全指数 (我我,我u个) 国际_ 我我 = （i，i）->i->Int对于所有a.Ix a=>（a，a）->a->Int指数 (我我,我u个) 我我

--不要在任何地方内嵌此长错误消息！！
错误安全索引 时间： 国际 -> 国际 -> 国际
badSafeIndex:：Int->Int->Int错误安全索引 国际我' 国际n个 = [Char]->国际对于所有a.[Char]->a错误没有堆栈跟踪 ([字符]“数组索引错误；” [Char]->[Char]->[Char]对于所有a.[a]->[a]->[a]++ 国际->[字符]对于所有a.显示a=>a->[Char]显示 国际我' [Char]->[Char]->[Char]对于所有a.[a]->[a]->[a]++
                        [字符]“不在[0..范围内” [Char]->[Char]->[Char]对于所有a.[a]->[a]->[a]++ 国际->[字符]对于所有a.显示a=>a->[Char]显示 国际n个 [Char]->[Char]->[Char]对于所有a.[a]->[a]->[a]++ [字符]")")

{-#内联 不安全状态 #-}
不安全 时间： 阵列 我 e（电子） -> 国际 -> e（电子）
unsafeAt:：数组i e->Int->e不安全状态 (阵列 我_ 我_ 国际_ 数组#e阿珥#) (我# 国际#我#) =
    案例 数组#e->Int#->（#e#）对于所有a.数组#a->Int#->（#a#）索引数组# 数组#e阿珥# 国际#我# 属于 (# e（电子）e（电子） #) -> e（电子）e（电子）

--|查找数组中的元素而不强制
不安全状态# 时间： 阵列 我 e（电子） -> 国际 -> (# e（电子） #)
unsafeAt#：：数组i e->Int->（#e#）不安全状态# (阵列 我_ 我_ 国际_ 数组#e自动调整#) (我# 国际#我#) = 数组#e->Int#->（#e#）对于所有a.数组#a->Int#->（#a#）索引数组# 数组#e阿珥# 国际#我#

--|unsafeAt的便捷版本#
不安全AtA 时间： 适用的 （f）
          => 阵列 我 e（电子） -> 国际 -> （f） e（电子）
unsafeAt:：数组i e->Int->f e不安全AtA 阵列i eary系列 国际我 = 案例 数组e->Int->（#e#）对于所有阵列->Int->（#e#）不安全状态# 阵列i eary系列 国际我 属于 (# e（电子）e（电子） #) -> e->f e对于所有（f:：*->*）a.适用f=>a->f a纯净的 e（电子）e（电子）

--|构造数组的边界。
{-#内联 边界 #-}
边界 时间： 阵列 我 e（电子） -> (我,我)
边界：：数组i e->（i，i）边界 (阵列 我我 我u个 国际_ 数组#e_) = (我我,我u个)

--|数组中的元素数。
{-#内联 num个元素 #-}
num个元素 时间： 阵列 我 e（电子） -> 国际
numElements:：数组i e->IntnumElements（数字元素） (阵列 我_ 我_ 国际n个 数组#e_) = 国际n个

--|按升序排列的数组索引列表。
{-#内联 指数 #-}
指数 时间： Ix公司 我 => 阵列 我 e（电子） -> [我]
索引：：数组i e->[i]指数 (阵列 我我 我u个 国际_ 数组#e_) = （i，i）->[i]对于所有a.Ix a=>（a，a）->[a]范围 (我我,我u个)

--|按索引顺序排列的数组元素列表。
{-#内联 元素 #-}
电子元件 时间： 阵列 我 e（电子） -> [e（电子）]
elems:：数组i e->[e]元素 arr:：数组阿珥@(阵列 我_ 我_ 国际n个 数组#e_) =
    [e（电子）e（电子） | 国际我 <- [国际0 .. 国际n个 国际->国际->国际对于所有a.数字a=>a->a->a- 国际1], e（电子）e（电子） <- 数组i e->Int->[e]对于所有（f:：*->*），即适用的f=>数组ie->Int->f e不安全AtA 阵列i e阿珥 国际我]

--|元素右折
{-#不可用 foldrElems（文件夹元素） #-}
foldrElems（文件夹元素） 时间： (一 -> b条 -> b条) -> b条 -> 阵列 我 一 -> b条
foldrElems:：（a->b->b）->b->数组i a->bfoldrElems（文件夹元素） a->b->b（f） b条b0（b0） = \ arr:：数组i a阿珥@(阵列 我_ 我_ 国际n个 数组#a_) ->
  让
    转到：：Int->b去 国际我 | 国际我 国际->国际->布尔对于所有a.方程a=>a->a->Bool== 国际n个    = b条b0（b0）
         | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 数组i a阿珥 国际我
         = a->b->b（f） 一e（电子） (国际->b去 (国际我国际->国际->国际对于所有a.数字a=>a->a->a+国际1))
  在里面 国际->b去 国际0

--|元素的左折叠
｛-#可内联 foldlElems（折叠元素） #-}
foldlElems（折叠元素） 时间： (b条 -> 一 -> b条) -> b条 -> 阵列 我 一 -> b条
foldlElems:：（b->a->b）->b->数组i a->bfoldlElems（折叠元素） b->a->b（f） b条b0（b0） = \ arr:：数组i a阿珥@(阵列 我_ 我_ 国际n个 数组#a_) ->
  让
    转到：：Int->b去 国际我 | 国际我 国际->国际->布尔对于所有a.等式a=>a->a->Bool== (-国际1) = b条b0（b0）
         | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 数组i a阿珥 国际我
         = b->a->b（f） (国际->b去 (国际我国际->国际->国际对于所有a.数字a=>a->a->a-国际1)) 一e（电子）
  在里面 国际->b去 (国际n个Int->Int->Int对于所有a.数字a=>a->a->a-国际1)

--|在元素上进行严格的右折
{-#不可用 foldrElems的 #-}
foldrElems的 时间： (一 -> b条 -> b条) -> b条 -> 阵列 我 一 -> b条
foldrElems'：：（a->b->b）->b->数组i a->bfoldrElems的 a->b->b（f） b条b0（b0） = \ arr:：数组i a阿珥@(阵列 我_ 我_ 国际n个 数组#a_) ->
  让
    转到：：Int->b->b去 国际我 b条一 | 国际我 Int->Int->布尔对于所有a.方程a=>a->a->Bool== (-国际1) = b条一
           | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 数组i a阿珥 国际我
           = 国际->b->b去 (国际我国际->国际->国际对于所有a.数字a=>a->a->a-国际1) (a->b->b（f） 一e（电子） （b->b）->b->b对于所有a b（a->b）->a->b$! b条一)
  在里面 国际->b->b去 (国际n个国际->国际->国际对于所有a.数字a=>a->a->a-国际1) b条b0（b0）

--|元素上严格的左折
{-#不可用 foldlElems的 #-}
foldlElems的 时间： (b条 -> 一 -> b条) -> b条 -> 阵列 我 一 -> b条
foldlElems：：（b->a->b）->b->数组i a->b文件夹电子' b->a->b（f） b条b0（b0） = \ arr:：数组i a阿珥@(阵列 我_ 我_ 国际n个 数组#a_) ->
  让
    转到：：Int->b->b去 国际我 b条一 | 国际我 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际n个    = b条一
           | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 阵列i a阿珥 国际我
           = 内部->b->b去 (国际我国际->国际->国际对于所有a.数字a=>a->a->a+国际1) (b条一 b->b->b`序列` b->a->b（f） b条一 一e（电子）)
  在里面 国际->b->b去 国际0 b条b0（b0）

--|元素的左折没有起始值
{-#不可用 fold1项目 #-}
fold1项目 时间： (一 -> 一 -> 一) -> 阵列 我 一 -> 一
fold1Elems:：（a->a->a）->数组i a->afold1项目 a->a->a（f） = \ arr:：数组i a阿珥@(阵列 我_ 我_ 国际n个 数组#a_) ->
  让
    转到：：Int->a去 国际我 | 国际我 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0    = 数组i a->Int->a对于所有阵列->Int->e不安全状态 数组i a阿珥 国际0
         | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 数组i a阿珥 国际我
         = a->a->a（f） (国际->a去 (国际我国际->国际->国际对于所有a.数字a=>a->a->a-国际1)) 一e（电子）
  在里面
    如果 国际n个 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0 然后 [Char]->a（字符）对于所有a.[Char]->a错误无堆栈跟踪 [字符]“foldl1:空数组” 其他的 国际->a去 (国际n个国际->国际->国际对于所有a.数字a=>a->a->a-国际1)

--|将没有起始值的元素向右折叠
{-#不可用 foldr1项目 #-}
foldr1项目 时间： (一 -> 一 -> 一) -> 阵列 我 一 -> 一
foldr1Elems:：（a->a->a）->数组i a->afoldr1项目 a->a->a（f） = \ arr:：数组i a阿珥@(阵列 我_ 我_ 国际n个 数组#a_) ->
  让
    转到：：Int->a去 国际我 | 国际我 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际n个国际->国际->国际对于所有a.数字a=>a->a->a-国际1  = 数组i a->Int->a对于所有阵列->Int->e不安全 数组i a阿珥 国际我
         | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 数组i a阿珥 国际我
         = a->a->a（f） 一e（电子） (国际->a去 (国际我 国际->国际->国际对于所有a.数字a=>a->a->a+ 国际1))
  在里面
    如果 国际n个 Int->Int->布尔对于所有a.方程a=>a->a->Bool== 国际0 然后 [Char]->a（字符）对于所有a.[Char]->a错误无堆栈跟踪 [字符]“foldr1:empty数组” 其他的 国际->a去 国际0

--|按索引顺序排列的数组关联列表。
{-#内联 协会会员 #-}
协会会员 时间： Ix公司 我 => 阵列 我 e（电子） -> [(我, e（电子）)]
关联：：数组i e->[（i，e）]协会会员 arr:：数组阿珥@(阵列 我我 我u个 国际_ 数组#e_) =
    [(我我, e（电子）e（电子）) | 我我 <- （i，i）->[i]对于所有a.Ix a=>（a，a）->[a]范围 (我我,我u个), 让 !(# e（电子）e（电子） #) = 阵列i e阿珥 数组i e->i->（#e#）例如，Ix i=>阵列i e->i->（#e#）!# 我我]

--|“accumArray”函数处理关联中的重复索引
--使用/累加函数/列出，该函数组合了
--具有相同索引的关联。
--
--例如，给定某个索引类型@hist的值列表@
--生成内每个索引出现次数的直方图
--指定范围：
--
-->历史记录：：（Ix a，数字b）=>（a，a）->[a]->数组a b
-->历史bnds is=accumArray（+）0 bnds[（i，1）|i<-is，inRange bnds i]
--
--@accumArray@对应用累加的每个结果都很严格
--函数，尽管它在初始值中是惰性的。因此，与
--用“array”构建的数组，通常不应使用累积数组
--是递归的。
｛-#内联 累积阵列 #-}
accumArray（累计阵列） 时间： Ix公司 我
        => (e（电子） -> 一 -> e（电子）)        --^累加函数
        -> e（电子）                    --^初始值
        -> (我,我)                --数组的^边界
        -> [(我, 一)]             --^关联列表
        -> 阵列 我 e（电子）
accumArray：：（e->a->e）->e->（i，i）->[（i，a）]->数组ieaccumArray（累计阵列） e->a->e（f） e（电子）最初的 (我我,我u个) [（i，a）]是 =
    让 n：：整数n个 = （i，i）->国际对于所有i.Ix i=>（i，i）->Int安全范围大小 (我我,我u个)
    在里面 （e->a->e）->e->（i，i）->Int->[（Int，a）]->数组ie对于所有e a i。（e->a->e）->e->（i，i）->Int->[（Int，a）]->数组ieunsafeAccumArray’ e->a->e（f） e（电子）最初的 (我我,我u个) 国际n个
                         [(（i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我, 一e（电子）) | (我我, 一e（电子）) <- [（i，a）]是]

{-#内联 unsafeAccumArray（不安全累计阵列） #-}
unsafeAccumArray（不安全累计阵列） 时间： Ix公司 我 => (e（电子） -> 一 -> e（电子）) -> e（电子） -> (我,我) -> [(国际, 一)] -> 阵列 我 e（电子）
unsafeAccumArray：：（e->a->e）->e->（i，i）->[（Int，a）]->数组unsafeAccumArray（不安全累计阵列） e->a->e（f） e（电子）最初的 （i，i）b条 [（国际，a）]是 = （e->a->e）->e->（i，i）->Int->[（Int，a）]->数组ie对于所有e a i。（e->a->e）->e->（i，i）->Int->[（Int，a）]->数组ieunsafeAccumArray' e->a->e（f） e（电子）最初的 （i，i）b条 (（i，i）->国际对于所有i.Ix i=>（i，i）->Int范围大小 （i，i）b条) [（国际，a）]是

{-#内联 unsafeAccumArray’ #-}
unsafeAccumArray’ 时间： (e（电子） -> 一 -> e（电子）) -> e（电子） -> (我,我) -> 国际 -> [(国际, 一)] -> 阵列 我 e（电子）
unsafeAccumArray’：：（e->a->e）->e->（i，i）->Int->[（Int，a）]->数组i eunsafeAccumArray’ e->a->e（f） e（电子）最初的 (我我,我u个) n：：整数n个@(我# 国际#n个#) [（国际，a）]是 = （对于所有s.ST（阵列））->阵列对于所有a.（对于所有s.ST s a）->a运行ST (STRep s（阵列i e）->ST s（阵列e）对于所有s.STRip s a->ST s a标准时间 （ST代表s（阵列i e）->ST s（阵列i e））->STRep s（阵列i e）->ST s（阵列e）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 Int#->e->状态#s->（#状态#s，MutableArray#s e#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）newArray（新阵列）# 国际#n个# e（电子）最初的 州#第1页#          属于 { (# 状态#ss2秒#, 可变数组#s e马尔# #) ->
    （（（Int，a）->STRep s（数组i e）->STRep s（数组e））->STRep s（数组i e）->[（Int，a）]->STReps（数组e）对于所有a b（a->b->b）->b->[a]->b文件夹 (（e->a->e）->可变数组#s e->（国际，a）->STRep s（阵列）->STRep s（阵列）对于所有e a s b。（e->a->e）->可变阵列#s e->（Int，a）->STRep s b->STReps s b调整' e->a->e（f） 可变数组#s e马尔#) (i->i->Int->MutableArray#s e->STRep s（数组i e）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 可变阵列#s e马尔#) [（国际，a）]是 州#s2秒# })

{-#内联 调整 #-}
调整 时间： (e（电子） -> 一 -> e（电子）) -> 可变数组# 秒 e（电子） -> (国际, 一) -> STRep公司 秒 b条 -> STRep公司 秒 b条
--见注“填充”
调整：：（e->a->e）->可变阵列#s e->（Int，a）->STRep s b->STRep s b调整 e->a->e（f） 可变数组#s e马尔# (我# 国际#我#, 一新的) STRep s b型下一个
  = \州#第1页# -> 案例 可变数组#s e->Int#->State#s->（#State#s，e#）对于所有数据a。可变数组#d a->Int#->状态#d->（#状态#d，a#）readArray（读取阵列）# 可变数组#s e马尔# 国际#我# 州#第1页# 属于
                (# 州#s2秒#, e（电子）古老的 #) ->
                    案例 MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# (e->a->e（f） e（电子）古老的 一新的) 州#s2秒# 属于
                        状态#s第3页# -> STRep s b型下一个 州#第3节#

{-#内联 调整' #-}
调整' 时间： (e（电子） -> 一 -> e（电子）)
        -> 可变数组# 秒 e（电子）
        -> (国际, 一)
        -> STRep公司 秒 b条 -> STRep公司 秒 b条
调整'：：（e->a->e）->可变阵列#s e->（Int，a）->STRep s b->STReps s b调整' e->a->e（f） 可变数组#s e马尔# (我# 国际#我#, 一新的) STRep s b型下一个
  = \州#第1页# -> 案例 可变数组#s e->Int#->State#s->（#State#s，e#）对于所有d。可变数组#d a->Int#->状态#d->（#状态#d，a#）readArray（读取阵列）# 可变数组#s e马尔# 国际#我# 州#第1页# 属于
                (# 州#s2秒#, e（电子）古老的 #) ->
                    让 !组合：：e组合的 = e->a->e（f） e（电子）古老的 一新的
                    在里面 STRep s b型下一个 (MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# e（电子）组合的 州#s2秒#)


--|构造与第一个参数相同的数组，但它具有
--已被右参数中的关联更新。
--例如，如果@m@是一个1-原点，@n@by@n@矩阵，那么
--
-->m//[（i，i），0）|i<-[1..n]]
--
--是相同的矩阵，但对角线为零。
--
--关联列表中的重复索引按“数组”处理：
--Haskell 2010指定结果数组未定义（即底部），
--但GHC的实施使用了每个索引的最后一个关联。
{-#内联 (//) #-}
(//) 时间： Ix公司 我 => 阵列 我 e（电子） -> [(我, e（电子）)] -> 阵列 我 e（电子）
arr:：数组i e阿珥@(阵列 我我 我u个 国际n个 数组#e_) //：：数组i e->[（i，e）]->数组i e// [（i，e）]是 =
    数组i e->[（Int，e）]->数组i e对于所有的，即数组i e->[（Int，e）]->数组i e不安全替换 阵列i e阿珥 [(（i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我, e（电子）e（电子）) | (我我, e（电子）e（电子）) <- [（i，e）]是]

｛-#内联 不安全更换 #-}
不安全替换 时间： 阵列 我 e（电子） -> [(国际, e（电子）)] -> 阵列 我 e（电子）
unsafeReplace:：数组i e->[（Int，e）]->数组i e不安全替换 阵列i e阿珥 [（国际）]是 = （对于所有s.ST（阵列））->阵列对于所有a.（对于所有s.ST s a）->a运行ST (做
    STArray公司 我我 我u个 国际n个 可变数组#s e马尔# <- 阵列->ST（STArray s i e）对于所有i.s.阵列->ST（STArray s i e）解冻STArray 阵列i e阿珥
    STRep s（阵列i e）->ST s（阵列e）对于所有s.STRip s a->ST s a标准时间 (（（（Int，e）->STRep s（数组i e）->STRep s（数组e））->STRep s（数组i e）->[（Int，e）]->STReps（数组e）对于所有a b（a->b->b）->b->[a]->b文件夹 (可变阵列#s e->（Int，e）->STRep s（数组ie）->STRep s（数组ue）对于所有人来说。MutableArray#s e->（Int，e）->STRep s a->STReps s a填满 可变数组#s e马尔#) (i->i->Int->MutableArray#s e->STRep s（数组i e）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 可变数组#s e马尔#) [（国际）]是))

--|@'accum'f@接受数组和关联列表并累加
--使用累积函数@f@从列表中配对到数组中。
--因此，“accumArray”可以使用“accum”定义：
--
-->accumArray f z b=累计f（数组b[（i，z）|i<-范围b]）
--
--@accum@在应用累加的所有结果中都是严格的。
--然而，它在数组的初始值中是惰性的。
{-#内联 累计 #-}
累计 时间： Ix公司 我 => (e（电子） -> 一 -> e（电子）) -> 阵列 我 e（电子） -> [(我, 一)] -> 阵列 我 e（电子）
accum:：（e->a->e）->数组i e->[（i，a）]->数组i e累计 e->a->e（f） arr:：数组阿珥@(阵列 我我 我u个 国际n个 数组#e_) [（i，a）]是 =
    （e->a->e）->数组i e->[（Int，a）]->数组i e对于所有e a i（e->a->e）->数组i e->[（Int，a）]->数组i e不安全累计 e->a->e（f） 阵列i e阿珥 [(（i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我, 一e（电子）) | (我我, 一e（电子）) <- [（i，a）]是]

｛-#内联 不安全累计 #-}
不安全累计 时间： (e（电子） -> 一 -> e（电子）) -> 阵列 我 e（电子） -> [(国际, 一)] -> 阵列 我 e（电子）
unsafeAccum:：（e->a->e）->数组i e->[（Int，a）]->数组i e不安全累计 e->a->e（f） 阵列i e阿珥 [（国际，a）]是 = （对于所有s.ST（阵列））->阵列对于所有a.（对于所有s.ST s a）->a运行ST (做
    STArray公司 我我 我u个 国际n个 可变阵列#s e马尔# <- 阵列->ST（STArray s i e）对于所有i.s.阵列->ST（STArray s i e）解冻STArray 阵列i e阿珥
    STRep s（阵列i e）->ST s（阵列e）对于所有s.STRip s a->ST s a标准时间 (（（（Int，a）->STRep s（数组i e）->STRep s（数组e））->STRep s（数组i e）->[（Int，a）]->STReps（数组e）对于所有a b（a->b->b）->b->[a]->b文件夹 (（e->a->e）->可变数组#s e->（国际，a）->STRep s（阵列）->STRep s（阵列）对于所有e a s b。（e->a->e）->可变阵列#s e->（Int，a）->STRep s b->STReps s b调整' e->a->e（f） 可变数组#s e马尔#) (i->i->Int->可变阵列#s e->STRep s（阵列i e）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 可变数组#s e马尔#) [（国际，a）]是))

{-#内联 [1] 阿玛普 #-}  --参见注释[amap]
阿玛普 时间： (一 -> b条) -> 阵列 我 一 -> 阵列 我 b条
amap:：（a->b）->数组i a->Array i b阿玛普 a->b（f） arr:：数组i a阿珥@(阵列 我我 我u个 n：：整数n个@(我# 国际#n个#) 数组#a_) = （对于所有s.ST（阵列i b））->阵列i b对于所有a.（对于所有s.ST s a）->a运行ST (STRep s（阵列i b）->ST s（阵列ii b）对于所有s.STRip s a->ST s a标准时间 （STRep s（阵列i b）->ST s（阵列ii b））->STRep s（阵列i b）->ST s（阵列ii b）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 Int#->b->状态#s->（#状态#s，MutableArray#s b#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）newArray（新阵列）# 国际#n个# b条对于所有a.aarrEle底部 州#第1页# 属于
        (# 状态#ss2秒#, 可变数组#s b马尔# #) ->
          让 go:：Int->STRep s（数组i b）去 国际我 州#秒#
                | 国际我 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际n个    = i->i->Int->MutableArray#s b->STRep s（数组i b）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 可变阵列#s b马尔# 州#秒#
                | (# 一e（电子） #) <- 数组i a->Int->（#a#）对于所有阵列->Int->（#e#）不安全状态# 数组i a阿珥 国际我
                = 可变数组#s b->（Int，b）->STRep s（数组i b）->STRep s（数组ii b）对于所有人来说。MutableArray#s e->（Int，e）->STRep s a->STReps s a填满 可变数组#s b马尔# (国际我, a->b（f） 一e（电子）) (Int->STRep s（数组i b）去 (国际我国际->国际->国际对于所有a.数字a=>a->a->a+国际1)) 州#秒#
          在里面 Int->STRep s（数组i b）去 国际0 州#第2页# )

{-注释[amap]~~~~~~~~~~~~~~amap最初的定义如下：amap f arr@（数组l u n _）=unsafeArray'（l，u）n[（i，f（unsafeAt arr i））|i<-[0..n-1]]有两个问题：1.enumFromTo实现为不可能的在n<0的情况下，会复制数组冻结代码。2.此实现依赖于列表融合以提高效率。整齐要实现“amap/强制”规则，我们需要延迟内联amap直到simplifier阶段1，即eftIntList规则生效让这一切变得不可能。（参考编号8767）-}


--参见Breitner、Eisenberg、Peyton Jones和Weirich，“安全零成本
--对哈斯克尔的胁迫”，第6.5节：
--   http://research.microsoft.com/en-us/um/people/simonpj/papers/ext-f/corlecible.pdf
{-#规则
“amap/胁迫” 阿玛普 胁迫 = 胁迫  --参见注释[amap]
 #-}

--第二函子定律：
{-#规则
“amap/amap” 对于所有人 （f） 克 一 . 阿玛普 （f） (阿玛普 克 一) = 阿玛普 (（f） . 克) 一
 #-}

--|“ixmap”允许对数组索引进行转换。
--可以认为它在右侧提供了功能组合
--使用原始数组所体现的映射。
--
--使用“fmap”可以实现数组值的类似转换
--来自“Functor”类的“Array”实例。
{-#内联 ixmap地图 #-}
ixmap地图 时间： (Ix公司 我, Ix公司 j个) => (我,我) -> (我 -> j个) -> 阵列 j个 e（电子） -> 阵列 我 e（电子）
ixmap:：（i，i）->（i->j）->数组j e->数组i eixmap地图 (我我,我u个) i->j（f） 数组j e阿珥 =
    （i，i）->[（i，e）]->数组i e例如，Ix i=>（i，i）->[（i，e）]->数组i e阵列 (我我,我u个) [(我我, 数组j e阿珥 数组j e->j->e例如，Ix i=>阵列ie->i->e! i->j（f） 我我) | 我我 <- （i，i）->[i]对于所有a.Ix a=>（a，a）->[a]范围 (我我,我u个)]

{-#内联 eqArray（eq阵列） #-}
eqArray（eq阵列） 时间： (Ix公司 我, 等式 e（电子）) => 阵列 我 e（电子） -> 阵列 我 e（电子） -> 布尔
eqArray:：数组i e->数组i e->BooleqArray（eq阵列） arr1:：数组arr1型@(阵列 我l1级 我u1型 国际1个 数组#e_) arr2:：数组棱2@(阵列 我第二语言 我u2型 国际氮气 数组#e_) =
    如果 国际1个 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0 然后 国际氮气 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0 其他的
    我l1级 i->i->布尔对于所有a.等式a=>a->a->Bool== 我第二语言 布尔->布尔->布尔&& 我u1型 i->i->布尔对于所有a.等式a=>a->a->Bool== 我u2型 Bool->Bool->Bool&&
    [Bool]->Bool（布尔）和 [数组e->Int->e对于所有阵列->Int->e不安全状态 阵列i earr1型 国际我 e->e->布尔对于所有a.等式a=>a->a->Bool== 数组e->Int->e对于所有阵列->Int->e不安全状态 阵列i earr2型 国际我 | 国际我 <- [国际0 .. 国际1个 国际->国际->国际对于所有a.数字a=>a->a->a- 国际1]]

{-#内联 [1] cmpArray（cmp阵列） #-}
cmpArray（cmp阵列） 时间： (Ix公司 我, 订单 e（电子）) => 阵列 我 e（电子） -> 阵列 我 e（电子） -> 订购
cmpArray:：Array i e->数组i e->排序cmpArray（cmp阵列） 阵列i earr1型 阵列i e棱2 = [（i，e）]->[（i、e）]->订购对于所有a.订单a=>a->a->订单比较 (数组i e->[（i，e）]例如，Ix i=>数组i e->[（i，e）]协会会员 阵列i earr1型) (数组i e->[（i，e）]例如，Ix i=>数组i e->[（i，e）]协会会员 阵列i e棱2)

{-#内联 cmpIntArray（cmpInt阵列） #-}
cmpIntArray（cmpInt阵列） 时间： 订单 e（电子） => 阵列 国际 e（电子） -> 阵列 国际 e（电子） -> 订购
cmpIntArray:：数组整数->数组整数->排序cmpIntArray（cmpInt阵列） arr1:：数组Intearr1型@(阵列 国际l1级 国际u1型 国际1个 数组#e_) arr2:：数组Intearr2型@(阵列 国际第二语言 国际u2型 国际氮气 数组#e_) =
    如果 国际1个 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0 然后
        如果 国际氮气 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0 然后 订购均衡 其他的 订购书信电报
    其他的 如果 国际氮气 国际->国际->布尔对于所有a.等式a=>a->a->Bool== 国际0 然后 订购燃气轮机
    其他的 案例 Int->Int->订购对于所有a.订单a=>a->a->订单比较 国际l1级 国际第二语言 属于
             订购均衡    -> （Int->排序->排序）->排序->[Int]->排序对于所有a b（a->b->b）->b->[a]->b文件夹 Int->订购->订购合作管理计划 (Int->Int->订购对于所有a.订单a=>a->a->订单比较 国际u1型 国际u2型) [国际0 .. (国际1个 国际->国际->国际对于所有a.Ord a=>a->a->a`最小值` 国际氮气) 国际->国际->国际对于所有a.数字a=>a->a->a- 国际1]
             订购其他 -> 订购其他
  哪里
    cmp:：Int->订购->订购合作管理计划 国际我 订购休息 = 案例 e->e->订购对于所有a.或a=>a->a->订购比较 (数组Int e->Int->e对于所有阵列->Int->e不安全状态 阵列Int earr1型 国际我) (数组Int e->Int->e对于所有阵列->Int->e不安全状态 阵列Int e棱2 国际我) 属于
        订购均衡    -> 订购休息
        订购其他 -> 订购其他

{-#规则 “cmpArray/Int” cmpArray（cmpArray） = cmpIntArray（cmpIntArray） #-}

----------------------------------------------------------------------
--阵列实例

--自2.01起|@
实例 Functor（仿真器） (阵列 我) 哪里
    fmap:：（a->b）->数组i a->Array i b功能性维修计划 = （a->b）->数组i a->数组i b对于所有a b i。（a->b）->数组i a->数组i b阿玛普

    {-#内联 (<$) #-}
    一x个 <$：：a->数组i b->数组i a<$ 阵列 我我 我u个 n：：整数n个@(我# 国际#n个#) 数组#b_ =
        --遗憾的是，我们不能只使用“newSTArray”（带有“unsafeFreezeSTArray“）
        --因为这需要证明原始数组的索引
        --是“Ix”的实例。
        （对于所有s.ST（阵列ia））->阵列ia对于所有a.（对于所有s.ST s a）->a运行ST （（对于所有ST（阵列i a））->阵列i a）->（对于所有s.ST（阵列ia））->阵列ia对于所有a b（a->b）->a->b$ STRep s（阵列i a）->ST s（阵列ia）对于所有s.STRip s a->ST s a标准时间 （STRep s（阵列i a）->ST s（阵列ia））->STRep s（阵列i a）->ST s（阵列ia）对于所有a b（a->b）->a->b$ \州#第1页# ->
            案例 Int#->a->State#s->（#State#s，MutableArray#s a#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）新数组# 国际#n个# 一x个 州#第1页# 属于
                (# 州#s2秒#, MutableArray#s变量数组马尔# #) -> i->i->Int->MutableArray#s a->STRep s（数组i a）对于所有i是e。i->i->Int->MutableArray#s e->STRep s（数组i e）完成 我我 我u个 国际n个 MutableArray#s变量数组马尔# 州#s2秒#

--自2.01起|@
实例 (Ix公司 我, 等式 e（电子）) => 等式 (阵列 我 e（电子）) 哪里
    ==：：数组i e->数组i e->Bool(==) = 数组e->数组e->Bool对于所有（Ix i，等式）=>数组i e->数组i e->布尔eqArray（eq阵列）

--自2.01起|@
实例 (Ix公司 我, 订单 e（电子）) => 订单 (阵列 我 e（电子）) 哪里
    compare:：数组ie->数组ie->排序比较 = 阵列->阵列->排序对于所有（Ix i，Orde）=>数组i e->数组i e->排序cmpArray（cmp阵列）

--自2.01起|@
实例 (Ix公司 一, 显示 一, 显示 b条) => 显示 (阵列 一 b条) 哪里
    showsPrec:：Int->数组a b->[Char]->[Char]显示Prec 国际第页 数组a b一 =
        布尔->（[Char]->[Char]）->[Char]->[Char]showParen公司 (国际第页 国际->国际->布尔对于所有a.或a=>a->a->Bool> 国际应用程序预处理) （（[Char]->[Char]）->[Car]->[Char]）->（[Char]->[Char]）->[Char]->[Char]对于所有a b（a->b）->a->b$
        [Char]->[Char]->[Char]showString（显示字符串） [字符]“数组” （[Char]->[Char]）->（[Char]->[Char]）->[Char]->[Char]对于所有的b c a。（b->c）->（a->b）->a->c.
        国际->（a，a）->[Char]->[Char]对于所有a.显示a=>Int->a->[Char]->[Char]显示Prec 国际应用Prec1 (数组a b->（a，a）对于所有阵列i e->（i，i）边界 数组a b一) （[Char]->[Char]）->（[Char]->[Char]）->[Char]->[Char]对于所有的b c a。（b->c）->（a->b）->a->c.
        字符->[Char]->[Char]showChar（显示字符） 烧焦' ' （[Char]->[Char]）->（[Char]->[Char]）->[Char]->[Char]对于所有的b c a。（b->c）->（a->b）->a->c.
        Int->[（a，b）]->[Char]->[Char]对于所有a.显示a=>Int->a->[Char]->[Char]显示Prec 国际应用Prec1 (数组a b->[（a，b）]例如，Ix i=>数组i e->[（i，e）]协会会员 数组a b一)
        --“array”的优先级是应用程序的优先级

--Read实例位于GHC中。阅读

----------------------------------------------------------------------
--可变数组上的操作

{-闲置ADR问题：在扁平化之间有什么折衷将数据类型转换为@STArray ix ix（MutableArray#s elt）@，并使用照原样？在我看来，前者使用的heap和提供对边界各个部分的更快访问，而使用的代码的优点是提供现成的@（lo，hi）@对许多阵列相关功能所需的。哪一个赢了？是差异显著（可能不显著）。空闲AJG回答：当我查看输出的代码时（虽然是2多年前）似乎您经常需要元组，我们构建它经常发生。现在我们有了超载的专业设备不过可能会有所不同。-}

{-#内联 newSTArray（新STArray） #-}
newSTArray（新STArray） 时间： Ix公司 我 => (我,我) -> e（电子） -> 标准时间 秒 (STArray公司 秒 我 e（电子）)
newSTArray:：（i，i）->e->ST（STArray s i e）newSTArray（新STArray） (我我,我u个) e（电子）最初的 = STRep s（STArray s i e）->ST s（STArray s i e]）对于所有s.STRip s a->ST s a标准时间 （STRep s（STArray s i e）->ST s（STArray s i e]）->STRep s（STArray s i e）->ST s（STArray s i e]）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 （i，i）->国际对于所有i.Ix i=>（i，i）->Int安全范围大小 (我我,我u个)            属于 { n：：整数n个@(我# 国际#n个#) ->
    案例 Int#->e->状态#s->（#状态#s，MutableArray#s e#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）新数组# 国际#n个# e（电子）最初的 州#第1页#       属于 { (# 州#s2秒#, 可变数组#s e马尔# #) ->
    (# 州#s2秒#, i->i->Int->MutableArray#s e->STArray s i e对于所有这些，例如，i->i->Int->MutableArray#s e->STArray s i eSTArray公司 我我 我u个 国际n个 可变数组#s e马尔# #) }}

{-#内联 boundsSTArray公司 #-}
boundsSTArray公司 时间： STArray公司 秒 我 e（电子） -> (我,我)
boundsSTArray:：STArray s i e->（i，i）（边界STArray：：STArray s i e->（i，i））boundsSTArray公司 (STArray公司 我我 我u个 国际_ 可变数组#s e_) = (我我,我u个)

{-#内联 num元素STArray #-}
num元素STArray 时间： STArray公司 秒 我 e（电子） -> 国际
numElementsSTArray:：STArray s i e->Intnum元素STArray (STArray公司 我_ 我_ 国际n个 可变数组#s e_) = 国际n个

｛-#内联 读取阵列 #-}
readSTArray（readSTArray） 时间： Ix公司 我 => STArray公司 秒 我 e（电子） -> 我 -> 标准时间 秒 e（电子）
readSTArray:：STArray s i e->i->ST s ereadSTArray（readSTArray） marr：：STArray是马尔@(STArray公司 我我 我u个 国际n个 可变数组#s e_) 我我 =
    STArray系列->Int系列->ST系列对于所有人，即STArray s i e->Int->ST s e不安全的ReadSTArray STArray系列马尔 (（i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我)

{-#内联 不安全的ReadSTArray #-}
不安全的ReadSTArray 时间： STArray公司 秒 我 e（电子） -> 国际 -> 标准时间 秒 e（电子）
unsafeReadSTArray:：STArray s i e->Int->ST s eunsafeReadSTArray（非安全读取阵列） (STArray公司 我_ 我_ 国际_ 可变数组#s e马尔#) (我# 国际#我#)
    = STRep s e->ST s e对于所有s.STRip s a->ST s a标准时间 （STReps e->ST s e）->STRep s e->STs e对于所有a b（a->b）->a->b$ \州#第1页# -> 可变阵列#s e->Int#->STRep s e对于所有d。可变数组#d a->Int#->状态#d->（#状态#d，a#）readArray（读取阵列）# 可变数组#s e马尔# 国际#我# 州#第1页#

{-#内联 写入STArray #-}
写入STArray 时间： Ix公司 我 => STArray公司 秒 我 e（电子） -> 我 -> e（电子） -> 标准时间 秒 ()
writeSTArray:：STArray s i e->i->e->ST（）写入STArray marr：：STArray是马尔@(STArray公司 我我 我u个 国际n个 可变数组#s e_) 我我 e（电子）e（电子） =
    STArray s i e->Int->e->ST（）对于所有s，即STArray s i e->Int->e->ST（）不安全的WriteSTArray STArray系列马尔 (（i，i）->国际->i->国际对于所有i.Ix i=>（i，i）->Int->i->Int安全索引 (我我,我u个) 国际n个 我我) e（电子）e（电子）

{-#内联 不安全的WriteSTArray #-}
不安全的WriteSTArray 时间： STArray公司 秒 我 e（电子） -> 国际 -> e（电子） -> 标准时间 秒 ()
unsafeWriteSTArray:：STArrays->Int->e->ST（）不安全的WriteSTArray (STArray公司 我_ 我_ 国际_ 可变数组#s e马尔#) (我# 国际#我#) e（电子）e（电子） = STRep s（）->ST s（）对于所有s.STRip s a->ST s a标准时间 （STReps（）->ST（））->STRep s（）->ST（）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# e（电子）e（电子） 州#第1页# 属于
        州#s2秒# -> (# 州#s2秒#, () #)

----------------------------------------------------------------------
--在可变和不可变之间移动

冷冻STArray 时间： STArray公司 秒 我 e（电子） -> 标准时间 秒 (阵列 我 e（电子）)
freezeSTArray:：STArray s i e->ST s（数组i e）冷冻STArray (STArray公司 我我 我u个 n：：整数n个@(我# 国际#n个#) 可变数组#s e马尔#) = STRep s（阵列i e）->ST s（阵列e）对于所有a.ST代表s a->ST s a标准时间 （ST代表s（阵列i e）->ST s（阵列i e））->STRep s（阵列i e）->ST s（阵列e）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 Int#->e->状态#s->（#状态#s，MutableArray#s e#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）newArray（新阵列）# 国际#n个# e（电子）对于所有a.aarrEle底部 州#第1页#  属于 { (# 州#s2秒#, 可变数组#s e马尔# #) ->
    让 copy:：Int#->状态#s->状态#s复制 国际#我# 状态#s第3节# | Int#->布尔为True# (国际#我# Int#->Int#->内部#==# 国际#n个#) = 州#第3节#
                    | 布尔否则 =
            案例 可变数组#s e->Int#->State#s->（#State#s，e#）对于所有d。可变数组#d a->Int#->State#d->（#State#d，a#）readArray（读取阵列）# 可变数组#s e马尔# 国际#我# 州#第3节# 属于 { (# 州#第4节#, e（电子）e（电子） #) ->
            案例 MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# e（电子）e（电子） 州#第4节# 属于 { 州#第5节# ->
            Int#->状态#s->状态#s复制 (国际#我# Int#->Int#->内部#+# 国际#1#) 州#第5节# }} 在里面
    案例 Int#->状态#s->状态#s复制 国际#0# 州#s2秒#                    属于 { 状态#s第3页# ->
    案例 可变数组#s e->状态#s->（#状态#s，数组#e#）对于所有数据a。可变数组#d a->状态#d->（#状态#d，数组#a#）unsafeFreezeArray# 可变数组#s e马尔# 州#第3节#  属于 { (# 州#第4节#, 数组#e阿珥# #) ->
    (# 州#第4节#, i->i->Int->数组#e->数组ie例如，i->i->Int->Array#e->Array i e阵列 我我 我u个 国际n个 数组#e阿珥# #) }}}

{-#内联 非安全FreezeSTArray #-}
不安全FreezeSTArray 时间： STArray公司 秒 我 e（电子） -> 标准时间 秒 (阵列 我 e（电子）)
unsafeFreezeSTArray:：STArray s i e->ST s（数组i e）不安全FreezeSTArray (STArray公司 我我 我u个 国际n个 可变数组#s e马尔#) = STRep s（阵列i e）->ST s（阵列e）对于所有s.STRip s a->ST s a标准时间 （STRep s（阵列i e）->ST s（阵列e））->STRep s（阵列i e）->ST s（阵列e）对于所有a b（a->b）->a->b$ \状态#s第1页# ->
    案例 可变数组#s e->状态#s->（#状态#s，数组#e#）对于所有数据a。可变数组#d a->状态#d->（#状态#d，数组#a#）unsafeFreezeArray# 可变数组#s e马尔# 州#第1页#   属于 { (# 州#s2秒#, 数组#e阿珥# #) ->
    (# 州#s2秒#, i->i->Int->数组#e->数组ie例如，i->i->Int->Array#e->Array i e阵列 我我 我u个 国际n个 数组#e阿珥# #) }

thawSTArray（thawSTA阵列） 时间： 阵列 我 e（电子） -> 标准时间 秒 (STArray公司 秒 我 e（电子）)
解冻STArray:：数组i e->ST（STArray s i e）解冻STArray (阵列 我我 我u个 n：：整数n个@(我# 国际#n个#) 数组#e阿珥#) = STRep s（STArray s i e）->ST s（STArray s i e]）对于所有s.STRip s a->ST s a标准时间 （STRep s（STArray s i e）->ST s（STArray s i e]）->ST代表s（STArray s i e）->ST s（STArray s i e）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 Int#->e->状态#s->（#状态#s，MutableArray#s e#）对于所有d。Int#->a->状态#d->（#状态#d，可变数组#d a#）newArray（新阵列）# 国际#n个# e（电子）对于所有a.aarrEle底部 州#第1页#  属于 { (# 州#s2秒#, 可变数组#s e马尔# #) ->
    让 copy:：Int#->状态#s->状态#s复制 国际#我# 状态#s第3节# | 智力#->Bool为True# (国际#我# Int#->Int#->内部#==# 国际#n个#) = 州#第3节#
                    | 布尔否则 =
            案例 数组#e->Int#->（#e#）对于所有a.数组#a->Int#->（#a#）索引数组# 数组#e自动调整# 国际#我#    属于 { (# e（电子）e（电子） #) ->
            案例 MutableArray#s e->Int#->e->状态#s->状态#s对于所有d a.可变数组#d a->Int#->a->状态#d->状态#d写入阵列# 可变数组#s e马尔# 国际#我# e（电子）e（电子） 州#第3节# 属于 { 州#第4节# ->
            Int#->状态#s->状态#s复制 (国际#我# Int#->Int#->内部#+# 国际#1#) 州#第4页# }} 在里面
    案例 Int#->状态#s->状态#s复制 国际#0# 州#s2秒#                    属于 { 州#第3节# ->
    (# 州#第3节#, i->i->Int->MutableArray#s e->STArray s i e对于所有这些，例如，i->i->Int->MutableArray#s e->STArray s i eSTArray（天线阵列） 我我 我u个 国际n个 可变阵列#s e马尔# #) }}

{-#内联 不安全的解冻 #-}
不安全的解冻 时间： 阵列 我 e（电子） -> 标准时间 秒 (STArray公司 秒 我 e（电子）)
unsafeThawSTArray:：数组i e->ST（STArray s i e）不安全的解冻 (阵列 我我 我u个 国际n个 数组#e阿珥#) = STRep s（STArray s i e）->ST s（STArray s i e]）对于所有s.STRip s a->ST s a标准时间 （STRep s（STArray s i e）->ST s（STArray s i e]）->STRep s（STArray s i e）->ST s（STArray s i e]）对于所有a b（a->b）->a->b$ \州#第1页# ->
    案例 数组#e->State#s->（#State#s，MutableArray#s e#）对于所有d。数组#a->State#d->（#State#d，MutableArray#d a#）非安全ThawArray# 数组#e自动调整# 州#第1页#      属于 { (# 州#s2秒#, 可变数组#s e马尔# #) ->
    (# 州#s2秒#, i->i->Int->MutableArray#s e->STArray s i e对于所有的i e。i->i->Int->可变阵列#s e->STArray s i eSTArray（天线阵列） 我我 我u个 国际n个 可变数组#s e马尔# #) }