X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=Data%2FArray.hs;h=263f9707c669dafb9cf62060e7dfb8650db68d65;hb=e9e2a5412bb7cda8d13a063ac403d9f18ac97380;hp=499f79184cf4119e54381d6b77ba62ceb1478974;hpb=9812e0a321ec0ed8f9e53eb2febfb14c79564200;p=ghc-base.git

diff --git a/Data/Array.hs b/Data/Array.hs
index 499f791..263f970 100644
--- a/Data/Array.hs
+++ b/Data/Array.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS -fno-implicit-prelude #-}
+{-# OPTIONS_GHC -fno-implicit-prelude #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Array 
@@ -11,24 +11,35 @@
 --
 -- Basic non-strict arrays.
 --
+-- /Note:/ The "Data.Array.IArray" module provides more general interface
+-- to immutable arrays: it defines operations with the same names as
+-- those defined below, but with more general types, and also defines
+-- 'Array' instances of the relevant classes.  To use that more general
+-- interface, import "Data.Array.IArray" but not "Data.Array".
 -----------------------------------------------------------------------------
 
 module  Data.Array 
 
     ( 
+    -- * Immutable non-strict arrays
+    -- $intro
       module Data.Ix		-- export all of Ix 
     , Array 			-- Array type is abstract
 
+    -- * Array construction
     , array	    -- :: (Ix a) => (a,a) -> [(a,b)] -> Array a b
     , listArray     -- :: (Ix a) => (a,a) -> [b] -> Array a b
+    , accumArray    -- :: (Ix a) => (b -> c -> b) -> b -> (a,a) -> [(a,c)] -> Array a b
+    -- * Accessing arrays
     , (!)           -- :: (Ix a) => Array a b -> a -> b
     , bounds        -- :: (Ix a) => Array a b -> (a,a)
     , indices       -- :: (Ix a) => Array a b -> [a]
     , elems         -- :: (Ix a) => Array a b -> [b]
     , assocs        -- :: (Ix a) => Array a b -> [(a,b)]
-    , accumArray    -- :: (Ix a) => (b -> c -> b) -> b -> (a,a) -> [(a,c)] -> Array a b
+    -- * Incremental array updates
     , (//)          -- :: (Ix a) => Array a b -> [(a,b)] -> Array a b
     , accum         -- :: (Ix a) => (b -> c -> b) -> Array a b -> [(a,c)] -> Array a b
+    -- * Derived arrays
     , ixmap         -- :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c -> Array a b
 
     -- Array instances:
@@ -44,17 +55,50 @@ module  Data.Array
 
     ) where
 
-import Data.Dynamic
+import Data.Ix
 
 #ifdef __GLASGOW_HASKELL__
-import Data.Ix
-import GHC.Arr		-- Most of the hard work is done here
-import GHC.Err		( undefined )
+import GHC.Arr		        -- Most of the hard work is done here
+import Data.Generics.Basics     -- To provide a Data instance
+import Data.Generics.Instances  -- To provide a Data instance
+import GHC.Err ( error )        -- Needed for Data instance
 #endif
 
 #ifdef __HUGS__
 import Hugs.Array
 #endif
 
-#include "Dynamic.h"
+#ifdef __NHC__
+import Array		-- Haskell'98 arrays
+#endif
+
+import Data.Typeable
+#include "Typeable.h"
 INSTANCE_TYPEABLE2(Array,arrayTc,"Array")
+
+#ifdef __GLASGOW_HASKELL__
+
+-- This instance preserves data abstraction at the cost of inefficiency.
+-- We omit reflection services for the sake of data abstraction.
+
+instance (Typeable a, Data b, Ix a) => Data (Array a b)
+ where
+  gfoldl f z a = z (listArray (bounds a)) `f` (elems a)
+  toConstr _   = error "toConstr"
+  gunfold _ _  = error "gunfold"
+  dataTypeOf _ = mkNorepType "Data.Array.Array"
+
+#endif
+
+{- $intro
+Haskell provides indexable /arrays/, which may be thought of as functions
+whose domains are isomorphic to contiguous subsets of the integers.
+Functions restricted in this way can be implemented efficiently;
+in particular, a programmer may reasonably expect rapid access to
+the components.  To ensure the possibility of such an implementation,
+arrays are treated as data, not as general functions.
+
+Since most array functions involve the class 'Ix', this module is exported
+from "Data.Array" so that modules need not import both "Data.Array" and
+"Data.Ix".
+-}