ghc/lib/std/Array.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1994-1999
   3 %
   4
   5 \section[Array]{Module @Array@}
   6
   7 \begin{code}
   8 {-# OPTIONS -fno-implicit-prelude #-}
   9
  10 module  Array
  11
  12     (
  13       module Ix                 -- export all of Ix
  14     , Array                     -- Array type is abstract
  15
  16     , array         -- :: (Ix a) => (a,a) -> [(a,b)] -> Array a b
  17     , listArray     -- :: (Ix a) => (a,a) -> [b] -> Array a b
  18     , (!)           -- :: (Ix a) => Array a b -> a -> b
  19     , bounds        -- :: (Ix a) => Array a b -> (a,a)
  20     , indices       -- :: (Ix a) => Array a b -> [a]
  21     , elems         -- :: (Ix a) => Array a b -> [b]
  22     , assocs        -- :: (Ix a) => Array a b -> [(a,b)]
  23     , accumArray    -- :: (Ix a) => (b -> c -> b) -> b -> (a,a) -> [(a,c)] -> Array a b
  24     , (//)          -- :: (Ix a) => Array a b -> [(a,b)] -> Array a b
  25     , accum         -- :: (Ix a) => (b -> c -> b) -> Array a b -> [(a,c)] -> Array a b
  26     , ixmap         -- :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c -> Array a b
  27
  28     -- Array instances:
  29     --
  30     --   Ix a => Functor (Array a)
  31     --   (Ix a, Eq b)  => Eq   (Array a b)
  32     --   (Ix a, Ord b) => Ord  (Array a b)
  33     --   (Ix a, Show a, Show b) => Show (Array a b)
  34     --   (Ix a, Read a, Read b) => Read (Array a b)
  35     --
  36
  37     -- Implementation checked wrt. Haskell 98 lib report, 1/99.
  38
  39     ) where
  40
  41 import Ix
  42 import PrelList
  43 import PrelShow
  44 import PrelArr          -- Most of the hard work is done here
  45 import PrelBase
  46
  47 infixl 9  !, //
  48 \end{code}
  49
  50
  51
  52 %*********************************************************
  53 %*                                                      *
  54 \subsection{Definitions of array, !, bounds}
  55 %*                                                      *
  56 %*********************************************************
  57
  58 \begin{code}
  59
  60 #ifdef USE_FOLDR_BUILD
  61 {-# INLINE indices #-}
  62 {-# INLINE elems #-}
  63 {-# INLINE assocs #-}
  64 #endif
  65
  66 {-# SPECIALISE listArray :: (Int,Int) -> [b] -> Array Int b #-}
  67 listArray             :: (Ix a) => (a,a) -> [b] -> Array a b
  68 listArray b vs        =  array b (zip (range b) vs)
  69
  70 {-# SPECIALISE indices :: Array Int b -> [Int] #-}
  71 indices               :: (Ix a) => Array a b -> [a]
  72 indices               =  range . bounds
  73
  74 {-# SPECIALISE elems :: Array Int b -> [b] #-}
  75 elems                 :: (Ix a) => Array a b -> [b]
  76 elems a               =  [a!i | i <- indices a]
  77
  78 {-# SPECIALISE assocs :: Array Int b -> [(Int,b)] #-}
  79 assocs                :: (Ix a) => Array a b -> [(a,b)]
  80 assocs a              =  [(i, a!i) | i <- indices a]
  81
  82 {-# SPECIALISE amap :: (b -> c) -> Array Int b -> Array Int c #-}
  83 amap                  :: (Ix a) => (b -> c) -> Array a b -> Array a c
  84 amap f a              =  array b [(i, f (a!i)) | i <- range b]
  85                          where b = bounds a
  86
  87 ixmap                 :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c -> Array a c
  88 ixmap b f a           =  array b [(i, a ! f i) | i <- range b]
  89 \end{code}
  90
  91
  92 %*********************************************************
  93 %*                                                      *
  94 \subsection{Instance declarations for Array type}
  95 %*                                                      *
  96 %*********************************************************
  97
  98 \begin{code}
  99 instance Ix a => Functor (Array a) where
 100   fmap = amap
 101
 102 instance  (Ix a, Eq b)  => Eq (Array a b)  where
 103     a == a'             =  assocs a == assocs a'
 104     a /= a'             =  assocs a /= assocs a'
 105
 106 instance  (Ix a, Ord b) => Ord (Array a b)  where
 107     compare a b = compare (assocs a) (assocs b)
 108
 109 instance  (Ix a, Show a, Show b) => Show (Array a b)  where
 110     showsPrec p a = showParen (p > 9) (
 111                     showString "array " .
 112                     shows (bounds a) . showChar ' ' .
 113                     shows (assocs a)                  )
 114     showList = showList__ (showsPrec 0)
 115
 116 {-
 117 instance  (Ix a, Read a, Read b) => Read (Array a b)  where
 118     readsPrec p = readParen (p > 9)
 119            (\r -> [(array b as, u) | ("array",s) <- lex r,
 120                                      (b,t)       <- reads s,
 121                                      (as,u)      <- reads t   ])
 122     readList = readList__ (readsPrec 0)
 123 -}
 124 \end{code}