-- | Curated re-export of immutable non-strict (boxed) arrays from "GHC.Arr"
module Mini.Data.Array (
  -- * Type
  Array,

  -- * Class
  Ix (
    inRange,
    index,
    range,
    rangeSize,
    unsafeIndex,
    unsafeRangeSize
  ),

  -- * Construction
  array,
  listArray,
  accumArray,

  -- * Conversion
  assocs,
  elems,
  indices,

  -- * Modification
  (//),
  accum,
  ixmap,

  -- * Query
  (!),
  (!?),
  bounds,
  numElements,
) where

import Data.Bool (
  bool,
 )
import GHC.Arr (
  Array,
  Ix (
    inRange,
    index,
    range,
    rangeSize,
    unsafeIndex,
    unsafeRangeSize
  ),
  accum,
  accumArray,
  array,
  assocs,
  bounds,
  elems,
  indices,
  ixmap,
  listArray,
  numElements,
  unsafeAt,
  (!),
  (//),
 )
import Prelude (
  Maybe (
    Just,
    Nothing
  ),
  ($),
  (.),
 )

infixl 9 !?

-- | The value at the given index in an array, unless out of range.
(!?) :: (Ix i) => Array i e -> i -> Maybe e
Array i e
arr !? :: forall i e. Ix i => Array i e -> i -> Maybe e
!? i
i =
  let b :: (i, i)
b = Array i e -> (i, i)
forall i e. Array i e -> (i, i)
bounds Array i e
arr
   in Maybe e -> Maybe e -> Bool -> Maybe e
forall a. a -> a -> Bool -> a
bool
        Maybe e
forall a. Maybe a
Nothing
        (e -> Maybe e
forall a. a -> Maybe a
Just (e -> Maybe e) -> (Int -> e) -> Int -> Maybe e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array i e -> Int -> e
forall i e. Array i e -> Int -> e
unsafeAt Array i e
arr (Int -> Maybe e) -> Int -> Maybe e
forall a b. (a -> b) -> a -> b
$ (i, i) -> i -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (i, i)
b i
i)
        (Bool -> Maybe e) -> Bool -> Maybe e
forall a b. (a -> b) -> a -> b
$ (i, i) -> i -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (i, i)
b i
i