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 PrelArr          -- Most of the hard work is done here
  44 import PrelBase
  45
  46 infixl 9  !, //
  47 \end{code}
  48
  49
  50
  51 %*********************************************************
  52 %*                                                      *
  53 \subsection{Definitions of array, !, bounds}
  54 %*                                                      *
  55 %*********************************************************
  56
  57 \begin{code}
  58
  59 #ifdef USE_FOLDR_BUILD
  60 {-# INLINE indices #-}
  61 {-# INLINE elems #-}
  62 {-# INLINE assocs #-}
  63 #endif
  64
  65 {-# SPECIALISE listArray :: (Int,Int) -> [b] -> Array Int b #-}
  66 listArray             :: (Ix a) => (a,a) -> [b] -> Array a b
  67 listArray b vs        =  array b (zip (range b) vs)
  68
  69 {-# SPECIALISE indices :: Array Int b -> [Int] #-}
  70 indices               :: (Ix a) => Array a b -> [a]
  71 indices               =  range . bounds
  72
  73 {-# SPECIALISE elems :: Array Int b -> [b] #-}
  74 elems                 :: (Ix a) => Array a b -> [b]
  75 elems a               =  [a!i | i <- indices a]
  76
  77 {-# SPECIALISE assocs :: Array Int b -> [(Int,b)] #-}
  78 assocs                :: (Ix a) => Array a b -> [(a,b)]
  79 assocs a              =  [(i, a!i) | i <- indices a]
  80
  81 {-# SPECIALISE amap :: (b -> c) -> Array Int b -> Array Int c #-}
  82 amap                  :: (Ix a) => (b -> c) -> Array a b -> Array a c
  83 amap f a              =  array b [(i, f (a!i)) | i <- range b]
  84                          where b = bounds a
  85
  86 ixmap                 :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c -> Array a c
  87 ixmap b f a           =  array b [(i, a ! f i) | i <- range b]
  88 \end{code}
  89
  90
  91 %*********************************************************
  92 %*                                                      *
  93 \subsection{Instance declarations for Array type}
  94 %*                                                      *
  95 %*********************************************************
  96
  97 \begin{code}
  98 instance Ix a => Functor (Array a) where
  99   fmap = amap
 100
 101 instance  (Ix a, Eq b)  => Eq (Array a b)  where
 102     a == a'             =  assocs a == assocs a'
 103     a /= a'             =  assocs a /= assocs a'
 104
 105 instance  (Ix a, Ord b) => Ord (Array a b)  where
 106     compare a b = compare (assocs a) (assocs b)
 107
 108 instance  (Ix a, Show a, Show b) => Show (Array a b)  where
 109     showsPrec p a = showParen (p > 9) (
 110                     showString "array " .
 111                     shows (bounds a) . showChar ' ' .
 112                     shows (assocs a)                  )
 113     showList = showList__ (showsPrec 0)
 114
 115 {-
 116 instance  (Ix a, Read a, Read b) => Read (Array a b)  where
 117     readsPrec p = readParen (p > 9)
 118            (\r -> [(array b as, u) | ("array",s) <- lex r,
 119                                      (b,t)       <- reads s,
 120                                      (as,u)      <- reads t   ])
 121     readList = readList__ (readsPrec 0)
 122 -}
 123 \end{code}