module Antelude.Array
(
module ArrayExport
, atIndex
, enumerate
, fromList
, fromNonEmpty
, map
, toList
, toNonEmpty
, update
) where
import safe Antelude.Bool ( and )
import safe Antelude.Function ( flip, (|>) )
import safe Antelude.Internal.TypesClasses
( Functor (fmap)
, List
, Maybe (..)
, NonEmpty
)
import safe qualified Antelude.List.NonEmpty as NE ( fromList, toList )
import safe Antelude.Tuple.Pair ( first, second )
import safe Data.Array as ArrayExport hiding
( assocs
, elems
, listArray
, (//)
, (!)
)
import safe qualified Data.Array as Array
import safe Prelude ( (<=), (>=) )
map :: (e -> f) -> Array i e -> Array i f
map :: forall e f i. (e -> f) -> Array i e -> Array i f
map = (e -> f) -> Array i e -> Array i f
forall a b. (a -> b) -> Array i a -> Array i b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
fromList :: (Array.Ix i) => (i, i) -> List a -> Array i a
fromList :: forall i a. Ix i => (i, i) -> List a -> Array i a
fromList = (i, i) -> [a] -> Array i a
forall i a. Ix i => (i, i) -> List a -> Array i a
Array.listArray
toList :: Array i e -> List e
toList :: forall i e. Array i e -> List e
toList = Array i e -> [e]
forall i e. Array i e -> List e
Array.elems
enumerate :: (Array.Ix i) => Array i e -> List (i, e)
enumerate :: forall i e. Ix i => Array i e -> List (i, e)
enumerate = Array i e -> [(i, e)]
forall i e. Ix i => Array i e -> List (i, e)
Array.assocs
fromNonEmpty :: (Array.Ix i) => (i, i) -> NonEmpty a -> Array i a
fromNonEmpty :: forall i a. Ix i => (i, i) -> NonEmpty a -> Array i a
fromNonEmpty (i, i)
bound NonEmpty a
ne = NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty a
ne [a] -> ([a] -> Array i a) -> Array i a
forall a b. a -> (a -> b) -> b
|> (i, i) -> [a] -> Array i a
forall i a. Ix i => (i, i) -> List a -> Array i a
fromList (i, i)
bound
toNonEmpty :: (Array.Ix i) => Array i a -> Maybe (NonEmpty a)
toNonEmpty :: forall i a. Ix i => Array i a -> Maybe (NonEmpty a)
toNonEmpty Array i a
arr = Array i a -> List a
forall i e. Array i e -> List e
toList Array i a
arr List a -> (List a -> Maybe (NonEmpty a)) -> Maybe (NonEmpty a)
forall a b. a -> (a -> b) -> b
|> List a -> Maybe (NonEmpty a)
forall a. List a -> Maybe (NonEmpty a)
NE.fromList
update :: (Array.Ix i) => List (i, e) -> Array i e -> Array i e
update :: forall i e. Ix i => List (i, e) -> Array i e -> Array i e
update = (Array i e -> List (i, e) -> Array i e)
-> List (i, e) -> Array i e -> Array i e
forall a b c. (a -> b -> c) -> b -> a -> c
flip Array i e -> List (i, e) -> Array i e
forall i e. Ix i => Array i e -> [(i, e)] -> Array i e
(Array.//)
atIndex :: (Array.Ix i) => i -> Array i e -> Maybe e
atIndex :: forall i e. Ix i => i -> Array i e -> Maybe e
atIndex i
idx Array i e
arr =
if (i
idx i -> i -> Bool
forall a. Ord a => a -> a -> Bool
>= Pair i i -> i
forall a b. Pair a b -> a
first (Array i e -> Pair i i
forall i e. Array i e -> (i, i)
Array.bounds Array i e
arr)) Bool -> Bool -> Bool
`and` (i
idx i -> i -> Bool
forall a. Ord a => a -> a -> Bool
<= Pair i i -> i
forall a b. Pair a b -> b
second (Array i e -> Pair i i
forall i e. Array i e -> (i, i)
Array.bounds Array i e
arr))
then
Array i e -> i -> e
forall i e. Ix i => Array i e -> i -> e
(Array.!) Array i e
arr i
idx e -> (e -> Maybe e) -> Maybe e
forall a b. a -> (a -> b) -> b
|> e -> Maybe e
forall a. a -> Maybe a
Just
else
Maybe e
forall a. Maybe a
Nothing