Data.Array.Base
| Авторские права | (c) Университет Глазго 2001 |
|---|---|
| Лицензия | BSD-стиль (см. файл libraries/base/LICENSE) |
| Поддержка | libraries@haskell.org |
| Устойчивость | экспериментальная |
| Переносимость | непереносимая (MPTCs, использует Control.Monad.ST) |
| Safe Haskell | Нет |
| Язык | Haskell2010 |
Описание
Основа для IArray и MArray. Не предназначена для внешнего использования; используйте IArray или MArray вместо этого.
ПРЕДУПРЕЖДЕНИЕ
Этот модуль считается внутренним.
Политика версионирования пакетов не применяется.
Содержание этого модуля может изменяться любым способом и без предупреждения между младшими версиями этого пакета.
Авторы, импортирующие этот модуль, должны тщательно отслеживать развитие.
class IArray (a :: Тип -> Тип -> Тип) e where Исходный код
Класс неизменяемых типов массивов.
Тип массива имеет вид (a i e) , где a — конструктор типа массива (вид * -> * -> *), i — тип индексов (член класса Ix), а e — тип элементов. Класс IArray параметризован как по a, так и по e, чтобы можно было определять специализированные по типу элементов экземпляры.
Минимальное полное определение
Методы
bounds :: Ix i => a i e -> (i, i) Исходный код
Извлекает границы неизменяемого массива
numElements :: Ix i => a i e -> Целое Исходный код
unsafeArray :: Ix i => (i, i) -> [(Целое, e)] -> a i e Исходный код
unsafeAt :: Ix i => a i e -> Целое -> e Исходный код
unsafeReplace :: Ix i => a i e -> [(Целое, e)] -> a i e Исходный код
unsafeAccum :: Ix i => (e -> e' -> e) -> a i e -> [(Целое, e')] -> a i e Исходный код
unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Целое, e')] -> a i e Исходный код
Примеры реализации
safeRangeSize :: Ix i => (i, i) -> Целое Исходный код
safeIndex :: Ix i => (i, i) -> Целое -> i -> Целое Исходный код
unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e) Source
unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e) Source
unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e) Source
Аргументы
| :: (IArray a e, Ix i) | |
| => (i, i) | границы массива: (наименьшее, наибольшее) |
| -> [(i, e)] | список ассоциаций |
| -> a i e |
Создаёт неизменяемый массив из пары границ и списка начальных ассоциаций.
Границы задаются парой наименьшей и наибольшей границ массива соответственно. Например, одномерный вектор длиной 10 имеет границы (1,10), а одномерный 10x10 массив имеет границы ((1,1),(10,10)).
Ассоциация — это пара вида (i,x), которая определяет значение массива в индексе i как x. Массив не определён, если какой-либо индекс в списке находится вне границ. Если какие-либо две ассоциации в списке имеют один и тот же индекс, значение в этом индексе зависит от реализации. (В GHC используется последнее заданное значение для этого индекса. Другие реализации также сделают это для необрамлённых массивов, но Haskell 98 требует, чтобы для Array значение в таких индексах было значением по умолчанию.)
Поскольку индексы должны быть проверены на эти ошибки, array строгий относительно аргумента границ и индексов списка ассоциаций. Является ли array строгим или нет относительно элементов зависит от типа массива: Array — это нестрогий тип массива, но все UArray массивы строгие. Таким образом, в нестрогом массиве возможны рекурсии, такие как следующие:
a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i \<- [2..100]])
Не каждый индекс в пределах границ массива должен появляться в списке ассоциаций, но значения, соответствующие индексам, которые не появляются, будут неопределёнными.
Если в любом измерении нижняя граница больше верхней границы, то массив является законным, но пустым. Обращение к пустому массиву всегда вызывает ошибку границ массива, но bounds по-прежнему возвращает границы, с которыми был построен массив.
listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i e Source
Создаёт неизменяемый массив из списка начальных элементов. Список задаёт элементы массива в порядке возрастания, начиная с наименьшего индекса.
genArray :: (IArray a e, Ix i) => (i, i) -> (i -> e) -> a i e Source
Создаёт неизменяемый массив, используя функцию генератора.
С: array-0.5.6.0
listArrayST :: Ix i => (i, i) -> [e] -> ST s (STArray s i e) Source
listUArrayST :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e) Source
type ListUArray e = forall i. Ix i => (i, i) -> [e] -> UArray i e Source
(!) :: (IArray a e, Ix i) => a i e -> i -> e Source
Возвращает элемент неизменяемого массива по заданному индексу или выбрасывает исключение, если индекс находится вне границ.
(!?) :: (IArray a e, Ix i) => a i e -> i -> Maybe e Source
Возвращает Just элемент неизменяемого массива по заданному индексу или Nothing , если индекс находится вне границ.
С: array-0.5.6.0
indices :: (IArray a e, Ix i) => a i e -> [i] Source
Возвращает список всех допустимых индексов в массиве.
elems :: (IArray a e, Ix i) => a i e -> [e] Source
Возвращает список всех элементов массива в том же порядке, что и их индексы.
assocs :: (IArray a e, Ix i) => a i e -> [(i, e)] Source
Возвращает содержимое массива в виде списка ассоциаций.
Аргументы
| :: (IArray a e, Ix i) | |
| => (e -> e' -> e) | Функция накопления |
| -> e | Элемент по умолчанию |
| -> (i, i) | Границы массива |
| -> [(i, e')] | Список ассоциаций |
| -> a i e | Возвращает: массив |
Создаёт неизменяемый массив из списка ассоциаций. В отличие от array, один и тот же индекс может встречаться несколько раз в списке ассоциаций; для комбинирования значений элементов с одним и тем же индексом используется функция накопления.
Например, для списка значений некоторого типа индекса hist производит гистограмму количества вхождений каждого индекса в указанном диапазоне:
hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b hist bnds is = accumArray (+) 0 bnds [(i, 1) | i\<-is, inRange bnds i]
(//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e Source
Принимает массив и список пар и возвращает массив, идентичный левому аргументу, за исключением того, что он был обновлён ассоциациями в правом аргументе. Например, если m — одномерный n×n массив, то m//[((i,i), 0) | i <- [1..n]] — это тот же массив, за исключением того, что по диагонали стоят нули.
Как и в случае с функцией array, если любые два сопоставления в списке имеют одинаковый индекс, значение в этом индексе зависит от реализации. (В GHC используется последнее указанное значение для этого индекса. Другие реализации также будут делать это для необрамленных массивов, но Haskell 98 требует, чтобы для Array значение в таких индексах было bottom.)
Для большинства типов массивов эта операция имеет сложность O(n), где n — размер массива. Однако пакет diffarray предоставляет тип массива, для которого эта операция имеет сложность, линейную относительно количества обновлений.
accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e Source
accum f принимает массив и список сопоставлений и накапливает пары из списка в массив с помощью функции накопления f. Таким образом accumArray может быть определен с помощью accum.
accumArray f z b = accum f (array b [(i, z) | i \<- range b])
amap :: (IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e Source
Возвращает новый массив, полученный из исходного массива путем применения функции к каждому элементу.
ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e Source
Возвращает новый массив, полученный из исходного массива путем применения функции к каждому индексу.
foldrArray :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b Source
Ленивое правое ассоциативное свёртку.
Since: array-0.5.8.0
foldlArray' :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b Source
Жесткая накапливающая левоассоциативная свёртка.
Since: array-0.5.8.0
foldlArray :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b Source
Ленивая левоассоциативная свёртка.
Since: array-0.5.8.0
foldrArray' :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b Source
Жесткая накапливающая правоассоциативная свёртка.
Since: array-0.5.8.0
traverseArray_ :: (IArray a e, Ix i, Applicative f) => (e -> f b) -> a i e -> f () Source
Преобразовать элементы в аппликативные действия, выполнить их последовательно слева направо и отбросить результаты.
Since: array-0.5.8.0
forArray_ :: (IArray a e, Ix i, Applicative f) => a i e -> (e -> f b) -> f () Source
forArray_ это traverseArray_ с переставленными аргументами.
Since: array-0.5.8.0
foldlArrayM' :: (IArray a e, Ix i, Monad m) => (b -> e -> m b) -> b -> a i e -> m b Source
Жесткая накапливающая левоассоциативная монадическая свёртка.
Since: array-0.5.8.0
foldrArrayM' :: (IArray a e, Ix i, Monad m) => (e -> b -> m b) -> b -> a i e -> m b Source
Жесткая накапливающая правоассоциативная монадическая свёртка.
Since: array-0.5.8.0
Массивы с необрамленными элементами. Для IArray предоставляются экземпляры для UArray с определенными типами элементов (Int, Float, Char, и т.д.; см. класс UArray для полного списка).
Массив UArray обычно будет более эффективным (по времени и памяти) по сравнению с эквивалентным Array с тем же типом элементов. Однако UArray строго относится к своим элементам — поэтому не используйте UArray если вам нужна несвязанность, которую предоставляет Array.
Поскольку интерфейс IArray предоставляет операции, перегруженные по типу массива, должно быть возможно просто изменить тип массива, используемый программой, скажем, с Array на UArray, чтобы получить преимущества необрамленных массивов (не забудьте импортировать Data.Array.Unboxed вместо Data.Array).
Конструкторы
| UArray !i !i !Int ByteArray# |
Примеры
Определено в Data.Array.Base Методыbounds :: Ix i => UArray i (StablePtr a) -> (i, i) Источник numElements :: Ix i => UArray i (StablePtr a) -> Int Источник unsafeArray :: Ix i => (i, i) -> [(Int, StablePtr a)] -> UArray i (StablePtr a) Источник unsafeAt :: Ix i => UArray i (StablePtr a) -> Int -> StablePtr a Источник unsafeReplace :: Ix i => UArray i (StablePtr a) -> [(Int, StablePtr a)] -> UArray i (StablePtr a) Источник unsafeAccum :: Ix i => (StablePtr a -> e' -> StablePtr a) -> UArray i (StablePtr a) -> [(Int, e')] -> UArray i (StablePtr a) Источник unsafeAccumArray :: Ix i => (StablePtr a -> e' -> StablePtr a) -> StablePtr a -> (i, i) -> [(Int, e')] -> UArray i (StablePtr a) Источник | |
| (Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e) Источник | |
| (Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e) Источник | |
| (Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e) Источник | |
| (Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e) Источник | |
Определено в Data.Array.Base |
unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [(Int, e)] -> e -> ST s (UArray i e) Source
unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e) Source
unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i) => UArray i e -> [(Int, e)] -> ST s (UArray i e) Source
unsafeAccumUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e) Source
unsafeAccumArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e) Source
eqUArray :: (IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool Source
cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering Source
cmpIntUArray :: (IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering Source
showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS Source
readIArray :: (IArray a e, Ix i, Read i, Read e) => ReadPrec (a i e) Source
nullStablePtr :: StablePtr a Source
arrEleBottom :: a Source
class Monad m => MArray (a :: Type -> Type -> Type) e (m :: Type -> Type) where Source
Класс изменяемых типов массивов.
Тип массива имеет вид (a i e) где a это конструктор типа массива (тип * -> * -> *), i это тип индекса (член класса Ix), и e это тип элемента.
Класс MArray параметризован как по a, так и по e (чтобы можно было определять экземпляры, специализированные для определённых типов элементов, так же, как и для IArray), а также по типу монады m, в которой будет манипулироваться изменяемым массивом.
Минимальное полное определение
getBounds, getNumElements, (newArray | unsafeNewArray_), unsafeRead, unsafeWrite
Методы
getBounds :: Ix i => a i e -> m (i, i) Source
Возвращает границы массива (минимальный, максимальный).
getNumElements :: Ix i => a i e -> m Int Source
Возвращает количество элементов в массиве.
newArray :: Ix i => (i, i) -> e -> m (a i e) Source
Создаёт новый массив, инициализируя каждый элемент предоставленным значением. Первый и второй элементы кортежа задают минимальный и максимальный индекс соответственно.
newArray_ :: Ix i => (i, i) -> m (a i e) Source
Создаёт новый массив, инициализируя каждый элемент неопределённым значением. В контексте монады, где операции должны быть детерминированными (например, монада ST), элементы массива инициализируются фиксированным, но неопределённым значением, таким как ноль. Первый и второй элементы кортежа задают минимальный и максимальный индекс соответственно.
unsafeNewArray_ :: Ix i => (i, i) -> m (a i e) Source
Создаёт новый массив, инициализируя каждый элемент неопределённым значением. Первый и второй элементы кортежа задают минимальный и максимальный индекс соответственно.
unsafeRead :: Ix i => a i e -> Int -> m e Source
unsafeWrite :: Ix i => a i e -> Int -> e -> m () Source
Примеры
newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e) Исходный код
Создаёт изменяемый массив из списка начальных элементов. Список задаёт элементы массива в порядке возрастания, начиная с наименьшего индекса. Первый и второй элементы кортежа задают наименьший и наибольший индекс соответственно.
newGenArray :: (MArray a e m, Ix i) => (i, i) -> (i -> m e) -> m (a i e) Исходный код
Создаёт изменяемый массив, используя функцию-генератор. Она вызывает функцию-генератор в порядке возрастания индексов.
С версии: array-0.5.6.0
readArray :: (MArray a e m, Ix i) => a i e -> i -> m e Исходный код
Чтение элемента из изменяемого массива
writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m () Source
Запись элемента в изменяемый массив
modifyArray :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m () Source
Изменение элемента в изменяемом массиве
Since: array-0.5.6.0
modifyArray' :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m () Source
Изменение элемента в изменяемом массиве. Строгое к записываемому элементу.
Since: array-0.5.6.0
getElems :: (MArray a e m, Ix i) => a i e -> m [e] Source
Возвращение списка всех элементов изменяемого массива
getAssocs :: (MArray a e m, Ix i) => a i e -> m [(i, e)] Source
Возвращение списка всех ассоциаций изменяемого массива в порядке индексов.
mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e) Source
Построение нового массива, полученного из исходного массива путем применения функции к каждому элементу.
mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e) Source
Построение нового массива, полученного из исходного массива путем применения функции к каждому индексу.
foldlMArray' :: (MArray a e m, Ix i) => (b -> e -> b) -> b -> a i e -> m b Source
Строгая левоассоциативная аккумулятивная свертка.
Since: array-0.5.8.0
foldrMArray' :: (MArray a e m, Ix i) => (e -> b -> b) -> b -> a i e -> m b Source
Строгая правоассоциативная аккумулятивная свертка.
Since: array-0.5.8.0
foldlMArrayM' :: (MArray a e m, Ix i) => (b -> e -> m b) -> b -> a i e -> m b Source
Строгая левоассоциативная моноидная аккумулятивная свертка.
Since: array-0.5.8.0
foldrMArrayM' :: (MArray a e m, Ix i) => (e -> b -> m b) -> b -> a i e -> m b Source
Строгая правоассоциативная моноидная аккумулятивная свертка.
Since: array-0.5.8.0
mapMArrayM_ :: (MArray a e m, Ix i) => (e -> m b) -> a i e -> m () Source
Применение элементов к моноидным операциям, последовательная обработка слева направо и отбрасывание результатов.
Since: array-0.5.8.0
forMArrayM_ :: (MArray a e m, Ix i) => a i e -> (e -> m b) -> m () Source
forMArrayM_ — это mapMArrayM_ со своими аргументами, поменянными местами.
Since: array-0.5.8.0
Изменяемый массив с необработанными элементами, который может быть обработан в ST монаде. Аргументы типа следующие:
-
s: аргумент переменной состояния для типаST -
i: тип индекса массива (должен быть экземпляромIx) -
e: тип элемента массива. Поддерживаются только определенные типы элементов.
STUArray обычно будет более эффективным (по времени и памяти) по сравнению с эквивалентной упакованной версией (STArray) с тем же типом элемента. Однако STUArray является строгим к своим элементам — поэтому не используйте STUArray если требуется нестрогость, которую предоставляет STArray.
Конструкторы
| STUArray !i !i !Int (MutableByteArray# s) |
Примеры реализации
| MArray (STUArray s) Int16 (ST s) Исходный код | |
Определено в Data.Array.Base МетодыgetBounds :: Ix i => STUArray s i Int16 -> ST s (i, i) Исходный код getNumElements :: Ix i => STUArray s i Int16 -> ST s Целое число Исходный код newArray :: Ix i => (i, i) -> Int16 -> ST s (STUArray s i Int16) Исходный код newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int16) Исходный код unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int16) Исходный код unsafeRead :: Ix i => STUArray s i Int16 -> Целое число -> ST s Int16 Исходный код unsafeWrite :: Ix i => STUArray s i Int16 -> Целое число -> Int16 -> ST s () Исходный код | |
| MArray (STUArray s) Int32 (ST s) Исходный код | |
Определено в Data.Array.Base МетодыgetBounds :: Ix i => STUArray s i Int32 -> ST s (i, i) Исходный код getNumElements :: Ix i => STUArray s i Int32 -> ST s Целое число Исходный код | |
| MArray (STUArray s) Int64 (ST s) Исходный код | |
Определено в Data.Array.Base МетодыgetBounds :: Ix i => STUArray s i (StablePtr a) -> ST s (i, i) Исходный код getNumElements :: Ix i => STUArray s i (StablePtr a) -> ST s Int Исходный код newArray :: Ix i => (i, i) -> StablePtr a -> ST s (STUArray s i (StablePtr a)) Исходный код newArray_ :: Ix i => (i, i) -> ST s (STUArray s i (StablePtr a)) Исходный код unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i (StablePtr a)) Исходный код unsafeRead :: Ix i => STUArray s i (StablePtr a) -> Int -> ST s (StablePtr a) Исходный код unsafeWrite :: Ix i => STUArray s i (StablePtr a) -> Int -> StablePtr a -> ST s () Исходный код | |
| Eq (STUArray s i e) Исходный код | |
unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e) Исходный код
bOOL_SCALE :: Int# -> Int# Исходный код
wORD_SCALE :: Int# -> Int# Исходный код
dOUBLE_SCALE :: Int# -> Int# Исходный код
fLOAT_SCALE :: Int# -> Int# Исходный код
safe_scale :: Int# -> Int# -> Int# Исходный код
bOOL_INDEX :: Int# -> Int# Исходный код
Индекс слова, в котором находятся элементы массива Bool.
bOOL_BIT :: Int# -> Word# Исходный код
bOOL_NOT_BIT :: Int# -> Word# Исходный код
freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) Исходный код
Преобразует изменяемый массив (любой экземпляр MArray) в неизменяемый массив (любой экземпляр IArray) путём создания полной копии.
freezeSTUArray :: STUArray s i e -> ST s (UArray i e) Исходный код
memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a) Исходный код
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) Source
Преобразует изменяемый массив в неизменяемый. Реализация может либо просто привести массив из одного типа в другой без копирования, либо выполнить полную копию массива.
Обратите внимание, что, поскольку массив, возможно, не копируется, любые последующие изменения, внесённые в изменяемую версию массива, могут быть распространены на неизменяемую версию. Поэтому это безопасно использовать, если изменяемая версия не изменяется после операции заморозки.
Реализация без копирования поддерживается только для определённых пар типов массивов; одно ограничение заключается в том, что типы массивов должны иметь идентичное представление. В GHC следующие пары типов массивов имеют некопируемую реализацию unsafeFreeze с O(1).
thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) Source
Преобразует неизменяемый массив (любой экземпляр IArray) в изменяемый массив (любой экземпляр MArray) путём создания полной его копии.
thawSTUArray :: UArray i e -> ST s (STUArray s i e) Source
memcpy_thaw :: MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a) Source
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) Source
Преобразует неизменяемый массив в изменяемый. Реализация может либо просто привести массив из одного типа в другой без копирования, либо выполнить полную копию массива.
Обратите внимание, что, поскольку массив, возможно, не копируется, любые последующие изменения, внесённые в изменяемую версию массива, могут быть распространены на неизменяемую версию. Поэтому это безопасно использовать только в том случае, если к неизменяемому массиву больше не будут обращаться в данном потоке, и нет возможности, что к нему могут обратиться в другом потоке. Если вы используете последовательность unsafeThaw_write_unsafeFreeze в многопоточной среде, необходимо гарантировать, что эта последовательность является атомарной по отношению к другим потокам, иначе может произойти сбой сборщика мусора (потому что запись может выполняться в замороженный массив).
Реализация без копирования поддерживается только для определённых пар типов массивов; одно ограничение заключается в том, что типы массивов должны иметь идентичное представление. В GHC следующие пары типов массивов имеют некопируемую реализацию unsafeThaw с O(1).
unsafeThawSTUArray :: UArray i e -> ST s (STUArray s i e) Source
unsafeThawIOArray :: Array ix e -> IO (IOArray ix e) Source
thawIOArray :: Array ix e -> IO (IOArray ix e) Source
freezeIOArray :: IOArray ix e -> IO (Array ix e) Source
unsafeFreezeIOArray :: IOArray ix e -> IO (Array ix e) Source
castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b) Source
Преобразует STUArray с одним типом элементов в другой с другим типом элементов. Все элементы результирующего массива будут неопределёнными (если вы не знаете, что делаете...).
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/9.12.1/docs/libraries/array-0.5.8.0-8d84/Data-Array-Base.html
